github.com/sagernet/sing-box@v1.2.7/cmd/sing-box/cmd_generate.go (about)

     1  package main
     2  
     3  import (
     4  	"crypto/rand"
     5  	"encoding/base64"
     6  	"encoding/hex"
     7  	"os"
     8  	"strconv"
     9  
    10  	"github.com/sagernet/sing-box/log"
    11  
    12  	"github.com/gofrs/uuid/v5"
    13  	"github.com/spf13/cobra"
    14  	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
    15  )
    16  
    17  var commandGenerate = &cobra.Command{
    18  	Use:   "generate",
    19  	Short: "Generate things",
    20  }
    21  
    22  func init() {
    23  	commandGenerate.AddCommand(commandGenerateUUID)
    24  	commandGenerate.AddCommand(commandGenerateRandom)
    25  	commandGenerate.AddCommand(commandGenerateWireGuardKeyPair)
    26  	commandGenerate.AddCommand(commandGenerateRealityKeyPair)
    27  	mainCommand.AddCommand(commandGenerate)
    28  }
    29  
    30  var (
    31  	outputBase64 bool
    32  	outputHex    bool
    33  )
    34  
    35  var commandGenerateRandom = &cobra.Command{
    36  	Use:   "rand <length>",
    37  	Short: "Generate random bytes",
    38  	Args:  cobra.ExactArgs(1),
    39  	Run: func(cmd *cobra.Command, args []string) {
    40  		err := generateRandom(args)
    41  		if err != nil {
    42  			log.Fatal(err)
    43  		}
    44  	},
    45  }
    46  
    47  func init() {
    48  	commandGenerateRandom.Flags().BoolVar(&outputBase64, "base64", false, "Generate base64 string")
    49  	commandGenerateRandom.Flags().BoolVar(&outputHex, "hex", false, "Generate hex string")
    50  }
    51  
    52  func generateRandom(args []string) error {
    53  	length, err := strconv.Atoi(args[0])
    54  	if err != nil {
    55  		return err
    56  	}
    57  
    58  	randomBytes := make([]byte, length)
    59  	_, err = rand.Read(randomBytes)
    60  	if err != nil {
    61  		return err
    62  	}
    63  
    64  	if outputBase64 {
    65  		_, err = os.Stdout.WriteString(base64.StdEncoding.EncodeToString(randomBytes) + "\n")
    66  	} else if outputHex {
    67  		_, err = os.Stdout.WriteString(hex.EncodeToString(randomBytes) + "\n")
    68  	} else {
    69  		_, err = os.Stdout.Write(randomBytes)
    70  	}
    71  
    72  	return err
    73  }
    74  
    75  var commandGenerateUUID = &cobra.Command{
    76  	Use:   "uuid",
    77  	Short: "Generate UUID string",
    78  	Args:  cobra.NoArgs,
    79  	Run: func(cmd *cobra.Command, args []string) {
    80  		err := generateUUID()
    81  		if err != nil {
    82  			log.Fatal(err)
    83  		}
    84  	},
    85  }
    86  
    87  func generateUUID() error {
    88  	newUUID, err := uuid.NewV4()
    89  	if err != nil {
    90  		return err
    91  	}
    92  	_, err = os.Stdout.WriteString(newUUID.String() + "\n")
    93  	return err
    94  }
    95  
    96  var commandGenerateWireGuardKeyPair = &cobra.Command{
    97  	Use:   "wg-keypair",
    98  	Short: "Generate WireGuard key pair",
    99  	Args:  cobra.NoArgs,
   100  	Run: func(cmd *cobra.Command, args []string) {
   101  		err := generateWireGuardKey()
   102  		if err != nil {
   103  			log.Fatal(err)
   104  		}
   105  	},
   106  }
   107  
   108  func generateWireGuardKey() error {
   109  	privateKey, err := wgtypes.GeneratePrivateKey()
   110  	if err != nil {
   111  		return err
   112  	}
   113  	os.Stdout.WriteString("PrivateKey: " + privateKey.String() + "\n")
   114  	os.Stdout.WriteString("PublicKey: " + privateKey.PublicKey().String() + "\n")
   115  	return nil
   116  }
   117  
   118  var commandGenerateRealityKeyPair = &cobra.Command{
   119  	Use:   "reality-keypair",
   120  	Short: "Generate reality key pair",
   121  	Args:  cobra.NoArgs,
   122  	Run: func(cmd *cobra.Command, args []string) {
   123  		err := generateRealityKey()
   124  		if err != nil {
   125  			log.Fatal(err)
   126  		}
   127  	},
   128  }
   129  
   130  func generateRealityKey() error {
   131  	privateKey, err := wgtypes.GeneratePrivateKey()
   132  	if err != nil {
   133  		return err
   134  	}
   135  	publicKey := privateKey.PublicKey()
   136  	os.Stdout.WriteString("PrivateKey: " + base64.RawURLEncoding.EncodeToString(privateKey[:]) + "\n")
   137  	os.Stdout.WriteString("PublicKey: " + base64.RawURLEncoding.EncodeToString(publicKey[:]) + "\n")
   138  	return nil
   139  }