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

ctfd.ChallengeStandard

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.

    It is the first historic implementation of its kind, with basic functionalities.

    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.ChallengeStandard("http", {
    category: "misc",
    description: "...",
    value: 500,
    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.ChallengeStandard("http",
    category="misc",
    description="...",
    value=500,
    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.NewChallengeStandard(ctx, "http", &ctfd.ChallengeStandardArgs{
			Category:    pulumi.String("misc"),
			Description: pulumi.String("..."),
			Value:       pulumi.Int(500),
			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.ChallengeStandard("http", new()
    {
        Category = "misc",
        Description = "...",
        Value = 500,
        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.ChallengeStandard;
import com.pulumi.ctfd.ChallengeStandardArgs;
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 ChallengeStandard("http", ChallengeStandardArgs.builder()
            .category("misc")
            .description("...")
            .value(500)
            .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 ChallengeStandard Resource

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

    Constructor syntax

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

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

    type: ctfd:ChallengeStandard
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 ChallengeStandardArgs
    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 ChallengeStandardArgs
    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 ChallengeStandardArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ChallengeStandardArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ChallengeStandardArgs
    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 challengeStandardResource = new Ctfd.ChallengeStandard("challengeStandardResource", new()
{
    Category = "string",
    Description = "string",
    Value = 0,
    Attribution = "string",
    ConnectionInfo = "string",
    MaxAttempts = 0,
    Name = "string",
    Next = 0,
    Requirements = new Ctfd.Inputs.ChallengeStandardRequirementsArgs
    {
        Behavior = "string",
        Prerequisites = new[]
        {
            "string",
        },
    },
    State = "string",
    Tags = new[]
    {
        "string",
    },
    Topics = new[]
    {
        "string",
    },
});

    example, err := ctfd.NewChallengeStandard(ctx, "challengeStandardResource", &ctfd.ChallengeStandardArgs{
	Category:       pulumi.String("string"),
	Description:    pulumi.String("string"),
	Value:          pulumi.Int(0),
	Attribution:    pulumi.String("string"),
	ConnectionInfo: pulumi.String("string"),
	MaxAttempts:    pulumi.Int(0),
	Name:           pulumi.String("string"),
	Next:           pulumi.Int(0),
	Requirements: &ctfd.ChallengeStandardRequirementsArgs{
		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"),
	},
})

    var challengeStandardResource = new ChallengeStandard("challengeStandardResource", ChallengeStandardArgs.builder()
    .category("string")
    .description("string")
    .value(0)
    .attribution("string")
    .connectionInfo("string")
    .maxAttempts(0)
    .name("string")
    .next(0)
    .requirements(ChallengeStandardRequirementsArgs.builder()
        .behavior("string")
        .prerequisites("string")
        .build())
    .state("string")
    .tags("string")
    .topics("string")
    .build());

    challenge_standard_resource = ctfd.ChallengeStandard("challengeStandardResource",
    category="string",
    description="string",
    value=0,
    attribution="string",
    connection_info="string",
    max_attempts=0,
    name="string",
    next=0,
    requirements={
        "behavior": "string",
        "prerequisites": ["string"],
    },
    state="string",
    tags=["string"],
    topics=["string"])

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

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

    ChallengeStandard 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 ChallengeStandard 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.
    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.
    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.ChallengeStandardRequirements
    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.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    Value int
    The value (points) of the challenge once solved.
    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.
    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 ChallengeStandardRequirementsArgs
    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.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    value Integer
    The value (points) of the challenge once solved.
    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.
    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 ChallengeStandardRequirements
    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.
    description string
    Description of the challenge, consider using multiline descriptions for better style.
    value number
    The value (points) of the challenge once solved.
    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.
    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 ChallengeStandardRequirements
    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.
    description str
    Description of the challenge, consider using multiline descriptions for better style.
    value int
    The value (points) of the challenge once solved.
    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.
    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 ChallengeStandardRequirementsArgs
    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.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    value Number
    The value (points) of the challenge once solved.
    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.
    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 ChallengeStandard 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 ChallengeStandard Resource

    Get an existing ChallengeStandard 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?: ChallengeStandardState, opts?: CustomResourceOptions): ChallengeStandard
    @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,
        description: Optional[str] = None,
        max_attempts: Optional[int] = None,
        name: Optional[str] = None,
        next: Optional[int] = None,
        requirements: Optional[ChallengeStandardRequirementsArgs] = None,
        state: Optional[str] = None,
        tags: Optional[Sequence[str]] = None,
        topics: Optional[Sequence[str]] = None,
        value: Optional[int] = None) -> ChallengeStandard
    func GetChallengeStandard(ctx *Context, name string, id IDInput, state *ChallengeStandardState, opts ...ResourceOption) (*ChallengeStandard, error)
    public static ChallengeStandard Get(string name, Input<string> id, ChallengeStandardState? state, CustomResourceOptions? opts = null)
    public static ChallengeStandard get(String name, Output<String> id, ChallengeStandardState state, CustomResourceOptions options)
    resources:  _:    type: ctfd:ChallengeStandard    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.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    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.ChallengeStandardRequirements
    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.
    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.
    Description string
    Description of the challenge, consider using multiline descriptions for better style.
    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 ChallengeStandardRequirementsArgs
    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.
    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.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    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 ChallengeStandardRequirements
    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.
    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.
    description string
    Description of the challenge, consider using multiline descriptions for better style.
    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 ChallengeStandardRequirements
    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.
    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.
    description str
    Description of the challenge, consider using multiline descriptions for better style.
    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 ChallengeStandardRequirementsArgs
    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.
    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.
    description String
    Description of the challenge, consider using multiline descriptions for better style.
    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.
    value Number
    The value (points) of the challenge once solved.

    Supporting Types

    ChallengeStandardRequirements, ChallengeStandardRequirementsArgs

    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