Docs Packages
  1. Packages
  2. CTFd Provider
  3. API Docs
  4. Challenge
CTFd v1.0.0 published on Monday, Jun 3, 2024 by CTFer.io
ctfer-io/pulumi-ctfd

ctfd.Challenge

Explore with Pulumi AI

ctfd logo
CTFd v1.0.0 published on Monday, Jun 3, 2024 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 provider builds a cleaner API on top of CTFd’s one to improve its adoption and lifecycle management.

    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.Challenge("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.Challenge("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/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.NewChallenge(ctx, "http", &ctfd.ChallengeArgs{
			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:  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.Challenge("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.Challenge;
import com.pulumi.ctfd.ChallengeArgs;
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 Challenge("http", ChallengeArgs.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 Challenge Resource

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

    Constructor syntax

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

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

    type: ctfd:Challenge
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 ChallengeArgs
    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 ChallengeArgs
    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 ChallengeArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ChallengeArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ChallengeArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

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

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

    example, err := ctfd.NewChallenge(ctx, "challengeResource", &ctfd.ChallengeArgs{
	Description: pulumi.String("string"),
	Value:       pulumi.Int(0),
	Category:    pulumi.String("string"),
	Minimum:     pulumi.Int(0),
	Function:    pulumi.String("string"),
	MaxAttempts: pulumi.Int(0),
	Decay:       pulumi.Int(0),
	Name:        pulumi.String("string"),
	Next:        pulumi.Int(0),
	Requirements: &ctfd.ChallengeRequirementsArgs{
		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"),
	},
	Type:           pulumi.String("string"),
	ConnectionInfo: pulumi.String("string"),
})

    var challengeResource = new Challenge("challengeResource", ChallengeArgs.builder()
    .description("string")
    .value(0)
    .category("string")
    .minimum(0)
    .function("string")
    .maxAttempts(0)
    .decay(0)
    .name("string")
    .next(0)
    .requirements(ChallengeRequirementsArgs.builder()
        .behavior("string")
        .prerequisites("string")
        .build())
    .state("string")
    .tags("string")
    .topics("string")
    .type("string")
    .connectionInfo("string")
    .build());

    challenge_resource = ctfd.Challenge("challengeResource",
    description="string",
    value=0,
    category="string",
    minimum=0,
    function="string",
    max_attempts=0,
    decay=0,
    name="string",
    next=0,
    requirements=ctfd.ChallengeRequirementsArgs(
        behavior="string",
        prerequisites=["string"],
    ),
    state="string",
    tags=["string"],
    topics=["string"],
    type="string",
    connection_info="string")

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

    type: ctfd:Challenge
properties:
    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
    type: string
    value: 0

    Challenge Resource Properties

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

    Inputs

    The Challenge resource accepts the following input properties:

    Category string
    Category of the challenge that CTFd groups by on the web UI.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Value int
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    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.ChallengeRequirements
    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.
    Type string
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    Category string
    Category of the challenge that CTFd groups by on the web UI.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Value int
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    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 ChallengeRequirementsArgs
    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.
    Type string
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    category String
    Category of the challenge that CTFd groups by on the web UI.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    value Integer
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    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 ChallengeRequirements
    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.
    type String
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    category string
    Category of the challenge that CTFd groups by on the web UI.
    description string
    Description of the challenge, consider using multiline descriptions for better style.
    value number
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    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 ChallengeRequirements
    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.
    type string
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    category str
    Category of the challenge that CTFd groups by on the web UI.
    description str
    Description of the challenge, consider using multiline descriptions for better style.
    value int
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    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 ChallengeRequirementsArgs
    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.
    type str
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    category String
    Category of the challenge that CTFd groups by on the web UI.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    value Number
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    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.
    type String
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Challenge 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 Challenge Resource

    Get an existing Challenge 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?: ChallengeState, opts?: CustomResourceOptions): Challenge
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = 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[ChallengeRequirementsArgs] = None,
        state: Optional[str] = None,
        tags: Optional[Sequence[str]] = None,
        topics: Optional[Sequence[str]] = None,
        type: Optional[str] = None,
        value: Optional[int] = None) -> Challenge
    func GetChallenge(ctx *Context, name string, id IDInput, state *ChallengeState, opts ...ResourceOption) (*Challenge, error)
    public static Challenge Get(string name, Input<string> id, ChallengeState? state, CustomResourceOptions? opts = null)
    public static Challenge get(String name, Output<String> id, ChallengeState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    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:
    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.ChallengeRequirements
    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.
    Type string
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    Value int
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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 ChallengeRequirementsArgs
    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.
    Type string
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    Value int
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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 ChallengeRequirements
    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.
    type String
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    value Integer
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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 ChallengeRequirements
    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.
    type string
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    value number
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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 ChallengeRequirementsArgs
    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.
    type str
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    value int
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".
    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.
    type String
    Type of the challenge defining its layout/behavior, either standard or dynamic (default).
    value Number
    The value (points) of the challenge once solved. Internally, the provider will handle what target is legitimate depending on the .type value, i.e. either value for "standard" or initial for "dynamic".

    Supporting Types

    ChallengeRequirements, ChallengeRequirementsArgs

    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 v1.0.0 published on Monday, Jun 3, 2024 by CTFer.io
    ctfer-io/pulumi-ctfd