Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. CTFd Provider
  3. API Docs
  4. ChallengeDynamic
CTFd v2.0.5 published on Thursday, Feb 13, 2025 by CTFer.io
ctfer-io/pulumi-ctfd

ctfd.ChallengeDynamic

Explore with Pulumi AI

ctfd logo
CTFd v2.0.5 published on Thursday, Feb 13, 2025 by CTFer.io
ctfer-io/pulumi-ctfd

    CTFd is built around the Challenge resource, which contains all the attributes to define a part of the Capture The Flag event.

    This implementation has support of a more dynamic behavior for its scoring through time/solves thus is different from a standard challenge.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as ctfd from "@ctfer-io/pulumi-ctfd";
import * as fs from "fs";

const http = new ctfd.ChallengeDynamic("http", {
    category: "misc",
    description: "...",
    value: 500,
    decay: 100,
    minimum: 50,
    state: "visible",
    "function": "logarithmic",
    topics: ["Misc"],
    tags: [
        "misc",
        "basic",
    ],
});
const httpFlag = new ctfd.Flag("httpFlag", {
    challengeId: http.id,
    content: "CTF{some_flag}",
});
const httpHint1 = new ctfd.Hint("httpHint1", {
    challengeId: http.id,
    content: "Some super-helpful hint",
    cost: 50,
});
const httpHint2 = new ctfd.Hint("httpHint2", {
    challengeId: http.id,
    content: "Even more helpful hint !",
    cost: 50,
    requirements: [httpHint1.id],
});
const httpFile = new ctfd.File("httpFile", {
    challengeId: http.id,
    contentb64: fs.readFileSync(".../image.png", { encoding: "base64" }),
});

    import pulumi
import base64
import ctfer-io_pulumi-ctfd as ctfd

http = ctfd.ChallengeDynamic("http",
    category="misc",
    description="...",
    value=500,
    decay=100,
    minimum=50,
    state="visible",
    function="logarithmic",
    topics=["Misc"],
    tags=[
        "misc",
        "basic",
    ])
http_flag = ctfd.Flag("httpFlag",
    challenge_id=http.id,
    content="CTF{some_flag}")
http_hint1 = ctfd.Hint("httpHint1",
    challenge_id=http.id,
    content="Some super-helpful hint",
    cost=50)
http_hint2 = ctfd.Hint("httpHint2",
    challenge_id=http.id,
    content="Even more helpful hint !",
    cost=50,
    requirements=[http_hint1.id])
http_file = ctfd.File("httpFile",
    challenge_id=http.id,
    contentb64=(lambda path: base64.b64encode(open(path).read().encode()).decode())(".../image.png"))

    package main

import (
	"encoding/base64"
	"os"

	"github.com/ctfer-io/pulumi-ctfd/sdk/v2/go/ctfd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func filebase64OrPanic(path string) string {
	if fileData, err := os.ReadFile(path); err == nil {
		return base64.StdEncoding.EncodeToString(fileData[:])
	} else {
		panic(err.Error())
	}
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		http, err := ctfd.NewChallengeDynamic(ctx, "http", &ctfd.ChallengeDynamicArgs{
			Category:    pulumi.String("misc"),
			Description: pulumi.String("..."),
			Value:       pulumi.Int(500),
			Decay:       pulumi.Int(100),
			Minimum:     pulumi.Int(50),
			State:       pulumi.String("visible"),
			Function:    pulumi.String("logarithmic"),
			Topics: pulumi.StringArray{
				pulumi.String("Misc"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("misc"),
				pulumi.String("basic"),
			},
		})
		if err != nil {
			return err
		}
		_, err = ctfd.NewFlag(ctx, "httpFlag", &ctfd.FlagArgs{
			ChallengeId: http.ID(),
			Content:     pulumi.String("CTF{some_flag}"),
		})
		if err != nil {
			return err
		}
		httpHint1, err := ctfd.NewHint(ctx, "httpHint1", &ctfd.HintArgs{
			ChallengeId: http.ID(),
			Content:     pulumi.String("Some super-helpful hint"),
			Cost:        pulumi.Int(50),
		})
		if err != nil {
			return err
		}
		_, err = ctfd.NewHint(ctx, "httpHint2", &ctfd.HintArgs{
			ChallengeId: http.ID(),
			Content:     pulumi.String("Even more helpful hint !"),
			Cost:        pulumi.Int(50),
			Requirements: pulumi.StringArray{
				httpHint1.ID(),
			},
		})
		if err != nil {
			return err
		}
		_, err = ctfd.NewFile(ctx, "httpFile", &ctfd.FileArgs{
			ChallengeId: http.ID(),
			Contentb64:  pulumi.String(filebase64OrPanic(".../image.png")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Pulumi;
using Ctfd = CTFerio.Ctfd;

	
string ReadFileBase64(string path) 
{
    return Convert.ToBase64String(Encoding.UTF8.GetBytes(File.ReadAllText(path)));
}

return await Deployment.RunAsync(() => 
{
    var http = new Ctfd.ChallengeDynamic("http", new()
    {
        Category = "misc",
        Description = "...",
        Value = 500,
        Decay = 100,
        Minimum = 50,
        State = "visible",
        Function = "logarithmic",
        Topics = new[]
        {
            "Misc",
        },
        Tags = new[]
        {
            "misc",
            "basic",
        },
    });

    var httpFlag = new Ctfd.Flag("httpFlag", new()
    {
        ChallengeId = http.Id,
        Content = "CTF{some_flag}",
    });

    var httpHint1 = new Ctfd.Hint("httpHint1", new()
    {
        ChallengeId = http.Id,
        Content = "Some super-helpful hint",
        Cost = 50,
    });

    var httpHint2 = new Ctfd.Hint("httpHint2", new()
    {
        ChallengeId = http.Id,
        Content = "Even more helpful hint !",
        Cost = 50,
        Requirements = new[]
        {
            httpHint1.Id,
        },
    });

    var httpFile = new Ctfd.File("httpFile", new()
    {
        ChallengeId = http.Id,
        Contentb64 = ReadFileBase64(".../image.png"),
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ctfd.ChallengeDynamic;
import com.pulumi.ctfd.ChallengeDynamicArgs;
import com.pulumi.ctfd.Flag;
import com.pulumi.ctfd.FlagArgs;
import com.pulumi.ctfd.Hint;
import com.pulumi.ctfd.HintArgs;
import com.pulumi.ctfd.File;
import com.pulumi.ctfd.FileArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var http = new ChallengeDynamic("http", ChallengeDynamicArgs.builder()
            .category("misc")
            .description("...")
            .value(500)
            .decay(100)
            .minimum(50)
            .state("visible")
            .function("logarithmic")
            .topics("Misc")
            .tags(            
                "misc",
                "basic")
            .build());

        var httpFlag = new Flag("httpFlag", FlagArgs.builder()
            .challengeId(http.id())
            .content("CTF{some_flag}")
            .build());

        var httpHint1 = new Hint("httpHint1", HintArgs.builder()
            .challengeId(http.id())
            .content("Some super-helpful hint")
            .cost(50)
            .build());

        var httpHint2 = new Hint("httpHint2", HintArgs.builder()
            .challengeId(http.id())
            .content("Even more helpful hint !")
            .cost(50)
            .requirements(httpHint1.id())
            .build());

        var httpFile = new File("httpFile", FileArgs.builder()
            .challengeId(http.id())
            .contentb64(Base64.getEncoder().encodeToString(Files.readAllBytes(Paths.get(".../image.png"))))
            .build());

    }
}

    Coming soon!

    Create ChallengeDynamic Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new ChallengeDynamic(name: string, args: ChallengeDynamicArgs, opts?: CustomResourceOptions);
    @overload
def ChallengeDynamic(resource_name: str,
                     args: ChallengeDynamicArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def ChallengeDynamic(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     minimum: Optional[int] = None,
                     category: Optional[str] = None,
                     value: Optional[int] = None,
                     decay: Optional[int] = None,
                     description: Optional[str] = None,
                     max_attempts: Optional[int] = None,
                     attribution: Optional[str] = None,
                     function: Optional[str] = None,
                     name: Optional[str] = None,
                     next: Optional[int] = None,
                     requirements: Optional[ChallengeDynamicRequirementsArgs] = None,
                     state: Optional[str] = None,
                     tags: Optional[Sequence[str]] = None,
                     topics: Optional[Sequence[str]] = None,
                     connection_info: Optional[str] = None)
    func NewChallengeDynamic(ctx *Context, name string, args ChallengeDynamicArgs, opts ...ResourceOption) (*ChallengeDynamic, error)
    public ChallengeDynamic(string name, ChallengeDynamicArgs args, CustomResourceOptions? opts = null)
    public ChallengeDynamic(String name, ChallengeDynamicArgs args)
public ChallengeDynamic(String name, ChallengeDynamicArgs args, CustomResourceOptions options)

    type: ctfd:ChallengeDynamic
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args ChallengeDynamicArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ChallengeDynamicArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ChallengeDynamicArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ChallengeDynamicArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ChallengeDynamicArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var challengeDynamicResource = new Ctfd.ChallengeDynamic("challengeDynamicResource", new()
{
    Minimum = 0,
    Category = "string",
    Value = 0,
    Decay = 0,
    Description = "string",
    MaxAttempts = 0,
    Attribution = "string",
    Function = "string",
    Name = "string",
    Next = 0,
    Requirements = new Ctfd.Inputs.ChallengeDynamicRequirementsArgs
    {
        Behavior = "string",
        Prerequisites = new[]
        {
            "string",
        },
    },
    State = "string",
    Tags = new[]
    {
        "string",
    },
    Topics = new[]
    {
        "string",
    },
    ConnectionInfo = "string",
});

    example, err := ctfd.NewChallengeDynamic(ctx, "challengeDynamicResource", &ctfd.ChallengeDynamicArgs{
	Minimum:     pulumi.Int(0),
	Category:    pulumi.String("string"),
	Value:       pulumi.Int(0),
	Decay:       pulumi.Int(0),
	Description: pulumi.String("string"),
	MaxAttempts: pulumi.Int(0),
	Attribution: pulumi.String("string"),
	Function:    pulumi.String("string"),
	Name:        pulumi.String("string"),
	Next:        pulumi.Int(0),
	Requirements: &ctfd.ChallengeDynamicRequirementsArgs{
		Behavior: pulumi.String("string"),
		Prerequisites: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	State: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	Topics: pulumi.StringArray{
		pulumi.String("string"),
	},
	ConnectionInfo: pulumi.String("string"),
})

    var challengeDynamicResource = new ChallengeDynamic("challengeDynamicResource", ChallengeDynamicArgs.builder()
    .minimum(0)
    .category("string")
    .value(0)
    .decay(0)
    .description("string")
    .maxAttempts(0)
    .attribution("string")
    .function("string")
    .name("string")
    .next(0)
    .requirements(ChallengeDynamicRequirementsArgs.builder()
        .behavior("string")
        .prerequisites("string")
        .build())
    .state("string")
    .tags("string")
    .topics("string")
    .connectionInfo("string")
    .build());

    challenge_dynamic_resource = ctfd.ChallengeDynamic("challengeDynamicResource",
    minimum=0,
    category="string",
    value=0,
    decay=0,
    description="string",
    max_attempts=0,
    attribution="string",
    function="string",
    name="string",
    next=0,
    requirements={
        "behavior": "string",
        "prerequisites": ["string"],
    },
    state="string",
    tags=["string"],
    topics=["string"],
    connection_info="string")

    const challengeDynamicResource = new ctfd.ChallengeDynamic("challengeDynamicResource", {
    minimum: 0,
    category: "string",
    value: 0,
    decay: 0,
    description: "string",
    maxAttempts: 0,
    attribution: "string",
    "function": "string",
    name: "string",
    next: 0,
    requirements: {
        behavior: "string",
        prerequisites: ["string"],
    },
    state: "string",
    tags: ["string"],
    topics: ["string"],
    connectionInfo: "string",
});

    type: ctfd:ChallengeDynamic
properties:
    attribution: string
    category: string
    connectionInfo: string
    decay: 0
    description: string
    function: string
    maxAttempts: 0
    minimum: 0
    name: string
    next: 0
    requirements:
        behavior: string
        prerequisites:
            - string
    state: string
    tags:
        - string
    topics:
        - string
    value: 0

    ChallengeDynamic Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The ChallengeDynamic resource accepts the following input properties:

    Category string
    Category of the challenge that CTFd groups by on the web UI.
    Decay int
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Minimum int
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    Value int
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    Attribution string
    Attribution to the creator(s) of the challenge.
    ConnectionInfo string
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    Function string
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    MaxAttempts int
    Maximum amount of attempts before being unable to flag the challenge.
    Name string
    Name of the challenge, displayed as it.
    Next int
    Suggestion for the end-user as next challenge to work on.
    Requirements CTFerio.Ctfd.Inputs.ChallengeDynamicRequirements
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    State string
    State of the challenge, either hidden or visible.
    Tags List<string>
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    Topics List<string>
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    Category string
    Category of the challenge that CTFd groups by on the web UI.
    Decay int
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Minimum int
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    Value int
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    Attribution string
    Attribution to the creator(s) of the challenge.
    ConnectionInfo string
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    Function string
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    MaxAttempts int
    Maximum amount of attempts before being unable to flag the challenge.
    Name string
    Name of the challenge, displayed as it.
    Next int
    Suggestion for the end-user as next challenge to work on.
    Requirements ChallengeDynamicRequirementsArgs
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    State string
    State of the challenge, either hidden or visible.
    Tags []string
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    Topics []string
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    category String
    Category of the challenge that CTFd groups by on the web UI.
    decay Integer
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    minimum Integer
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    value Integer
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution String
    Attribution to the creator(s) of the challenge.
    connectionInfo String
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    function String
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    maxAttempts Integer
    Maximum amount of attempts before being unable to flag the challenge.
    name String
    Name of the challenge, displayed as it.
    next Integer
    Suggestion for the end-user as next challenge to work on.
    requirements ChallengeDynamicRequirements
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state String
    State of the challenge, either hidden or visible.
    tags List<String>
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics List<String>
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    category string
    Category of the challenge that CTFd groups by on the web UI.
    decay number
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description string
    Description of the challenge, consider using multiline descriptions for better style.
    minimum number
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    value number
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution string
    Attribution to the creator(s) of the challenge.
    connectionInfo string
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    function string
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    maxAttempts number
    Maximum amount of attempts before being unable to flag the challenge.
    name string
    Name of the challenge, displayed as it.
    next number
    Suggestion for the end-user as next challenge to work on.
    requirements ChallengeDynamicRequirements
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state string
    State of the challenge, either hidden or visible.
    tags string[]
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics string[]
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    category str
    Category of the challenge that CTFd groups by on the web UI.
    decay int
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description str
    Description of the challenge, consider using multiline descriptions for better style.
    minimum int
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    value int
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution str
    Attribution to the creator(s) of the challenge.
    connection_info str
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    function str
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    max_attempts int
    Maximum amount of attempts before being unable to flag the challenge.
    name str
    Name of the challenge, displayed as it.
    next int
    Suggestion for the end-user as next challenge to work on.
    requirements ChallengeDynamicRequirementsArgs
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state str
    State of the challenge, either hidden or visible.
    tags Sequence[str]
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics Sequence[str]
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    category String
    Category of the challenge that CTFd groups by on the web UI.
    decay Number
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    minimum Number
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    value Number
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution String
    Attribution to the creator(s) of the challenge.
    connectionInfo String
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    function String
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    maxAttempts Number
    Maximum amount of attempts before being unable to flag the challenge.
    name String
    Name of the challenge, displayed as it.
    next Number
    Suggestion for the end-user as next challenge to work on.
    requirements Property Map
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state String
    State of the challenge, either hidden or visible.
    tags List<String>
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics List<String>
    List of challenge topics that are displayed to the administrators for maintenance and planification.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ChallengeDynamic resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing ChallengeDynamic Resource

    Get an existing ChallengeDynamic resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ChallengeDynamicState, opts?: CustomResourceOptions): ChallengeDynamic
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        attribution: Optional[str] = None,
        category: Optional[str] = None,
        connection_info: Optional[str] = None,
        decay: Optional[int] = None,
        description: Optional[str] = None,
        function: Optional[str] = None,
        max_attempts: Optional[int] = None,
        minimum: Optional[int] = None,
        name: Optional[str] = None,
        next: Optional[int] = None,
        requirements: Optional[ChallengeDynamicRequirementsArgs] = None,
        state: Optional[str] = None,
        tags: Optional[Sequence[str]] = None,
        topics: Optional[Sequence[str]] = None,
        value: Optional[int] = None) -> ChallengeDynamic
    func GetChallengeDynamic(ctx *Context, name string, id IDInput, state *ChallengeDynamicState, opts ...ResourceOption) (*ChallengeDynamic, error)
    public static ChallengeDynamic Get(string name, Input<string> id, ChallengeDynamicState? state, CustomResourceOptions? opts = null)
    public static ChallengeDynamic get(String name, Output<String> id, ChallengeDynamicState state, CustomResourceOptions options)
    resources:  _:    type: ctfd:ChallengeDynamic    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Attribution string
    Attribution to the creator(s) of the challenge.
    Category string
    Category of the challenge that CTFd groups by on the web UI.
    ConnectionInfo string
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    Decay int
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Function string
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    MaxAttempts int
    Maximum amount of attempts before being unable to flag the challenge.
    Minimum int
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    Name string
    Name of the challenge, displayed as it.
    Next int
    Suggestion for the end-user as next challenge to work on.
    Requirements CTFerio.Ctfd.Inputs.ChallengeDynamicRequirements
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    State string
    State of the challenge, either hidden or visible.
    Tags List<string>
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    Topics List<string>
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    Value int
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    Attribution string
    Attribution to the creator(s) of the challenge.
    Category string
    Category of the challenge that CTFd groups by on the web UI.
    ConnectionInfo string
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    Decay int
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Function string
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    MaxAttempts int
    Maximum amount of attempts before being unable to flag the challenge.
    Minimum int
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    Name string
    Name of the challenge, displayed as it.
    Next int
    Suggestion for the end-user as next challenge to work on.
    Requirements ChallengeDynamicRequirementsArgs
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    State string
    State of the challenge, either hidden or visible.
    Tags []string
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    Topics []string
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    Value int
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution String
    Attribution to the creator(s) of the challenge.
    category String
    Category of the challenge that CTFd groups by on the web UI.
    connectionInfo String
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    decay Integer
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    function String
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    maxAttempts Integer
    Maximum amount of attempts before being unable to flag the challenge.
    minimum Integer
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    name String
    Name of the challenge, displayed as it.
    next Integer
    Suggestion for the end-user as next challenge to work on.
    requirements ChallengeDynamicRequirements
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state String
    State of the challenge, either hidden or visible.
    tags List<String>
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics List<String>
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    value Integer
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution string
    Attribution to the creator(s) of the challenge.
    category string
    Category of the challenge that CTFd groups by on the web UI.
    connectionInfo string
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    decay number
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description string
    Description of the challenge, consider using multiline descriptions for better style.
    function string
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    maxAttempts number
    Maximum amount of attempts before being unable to flag the challenge.
    minimum number
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    name string
    Name of the challenge, displayed as it.
    next number
    Suggestion for the end-user as next challenge to work on.
    requirements ChallengeDynamicRequirements
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state string
    State of the challenge, either hidden or visible.
    tags string[]
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics string[]
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    value number
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution str
    Attribution to the creator(s) of the challenge.
    category str
    Category of the challenge that CTFd groups by on the web UI.
    connection_info str
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    decay int
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description str
    Description of the challenge, consider using multiline descriptions for better style.
    function str
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    max_attempts int
    Maximum amount of attempts before being unable to flag the challenge.
    minimum int
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    name str
    Name of the challenge, displayed as it.
    next int
    Suggestion for the end-user as next challenge to work on.
    requirements ChallengeDynamicRequirementsArgs
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state str
    State of the challenge, either hidden or visible.
    tags Sequence[str]
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics Sequence[str]
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    value int
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.
    attribution String
    Attribution to the creator(s) of the challenge.
    category String
    Category of the challenge that CTFd groups by on the web UI.
    connectionInfo String
    Connection Information to connect to the challenge instance, useful for pwn, web and infrastructure pentests.
    decay Number
    The decay defines from each number of solves does the decay function triggers until reaching minimum. This function is defined by CTFd and could be configured through .function.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    function String
    Decay function to define how the challenge value evolve through solves, either linear or logarithmic.
    maxAttempts Number
    Maximum amount of attempts before being unable to flag the challenge.
    minimum Number
    The minimum points for a dynamic-score challenge to reach with the decay function. Once there, no solve could have more value.
    name String
    Name of the challenge, displayed as it.
    next Number
    Suggestion for the end-user as next challenge to work on.
    requirements Property Map
    List of required challenges that needs to get flagged before this one being accessible. Useful for skill-trees-like strategy CTF.
    state String
    State of the challenge, either hidden or visible.
    tags List<String>
    List of challenge tags that will be displayed to the end-user. You could use them to give some quick insights of what a challenge involves.
    topics List<String>
    List of challenge topics that are displayed to the administrators for maintenance and planification.
    value Number
    The value (points) of the challenge once solved. It is mapped to initial under the hood, but displayed as value for consistency with the standard challenge.

    Supporting Types

    ChallengeDynamicRequirements, ChallengeDynamicRequirementsArgs

    Behavior string
    Behavior if not unlocked, either hidden or anonymized.
    Prerequisites List<string>
    List of the challenges ID.
    Behavior string
    Behavior if not unlocked, either hidden or anonymized.
    Prerequisites []string
    List of the challenges ID.
    behavior String
    Behavior if not unlocked, either hidden or anonymized.
    prerequisites List<String>
    List of the challenges ID.
    behavior string
    Behavior if not unlocked, either hidden or anonymized.
    prerequisites string[]
    List of the challenges ID.
    behavior str
    Behavior if not unlocked, either hidden or anonymized.
    prerequisites Sequence[str]
    List of the challenges ID.
    behavior String
    Behavior if not unlocked, either hidden or anonymized.
    prerequisites List<String>
    List of the challenges ID.

    Package Details

    Repository
    ctfd ctfer-io/pulumi-ctfd
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the ctfd Terraform Provider.
    ctfd logo
    CTFd v2.0.5 published on Thursday, Feb 13, 2025 by CTFer.io
    ctfer-io/pulumi-ctfd