Getting started with the go language is simple: go implements the Caesar password

Use Caesar's password to move characters on text . call  

strings.Map

  Method .

1  Caesar code encryption

Caesar code （ English ：Caesar cipher）, Or Caesar encryption 、 Caesar transforms 、 Transform encryption , It's the simplest and most widely known encryption technology .

The Caesar code is a kind of

Replace encryption

technology , All the letters in the plaintext go backwards in the alphabet （ Or forward ） Offset by a fixed number and replaced with ciphertext . for example , When the offset is zero  3  When , All the letters  A  Will be replaced by  D;B  become E, And so on . This encryption method is named after Caesar in the Roman Republic , It is said that Caesar used this method to contact his generals .

Plaintext alphabet ：ABCDEFGHIJKLMNOPQRSTUVWXYZ  Ciphertext alphabet ：DEFGHIJKLMNOPQRSTUVWXYZABC

design idea

• Set plaintext and move step size （ Secret text ）

• Convert clear text to lowercase , Prepare clear text byte slices and ciphertext slices

• Each plaintext character rotates according to the displacement step and is stored in the ciphertext

• Back to ciphertext

2 Go Realization

Caesar passwords are generally delivered in the form of passwords . Like this string of code “

exxegoexsrgi

” It's a password .

By moving the letters , We can encode messages . This prevents casual snooping . stay  Go  in , We can use  

strings.Map

  Method to achieve this .

2.1  Import package

import (
 "fmt"
 "strings" // Include string operation related methods
)

2.2  To write  caesar  Method

Then let's write  

caesarEn()

  Caesar password encryption method . This will receive a string and return a modified string .

It moves characters , Then move the character to the valid range .

//  Caesar code encryption
func caesarEn(strRaw string, step byte) string {
 //1.  Make text lowercase
 str_raw := strings.ToLower(strRaw)
 //2.  Define the step size
 step_move := step
 //3.  Convert a string to a plaintext character slice
 str_slice_src := []byte(str_raw)
 fmt.Println("Clear text character slice:", str_slice_src)

 //4.  Create a ciphertext character slice
 str_slice_dst := str_slice_src

 //5. Loop through text slices
 for i := 0; i < len(str_slice_src); i++ {
 //6. If the plaintext feature of the current period is within the displacement range , Please add a displacement step directly to save the ciphertext character slice
 if str_slice_src[i] < 123-step_move {
 str_slice_dst[i] = str_slice_src[i] + step_move
 } else { //7.  If plaintext characters are out of range , Then add the step length after displacement and subtract  26
 str_slice_dst[i] = str_slice_src[i] + step_move - 26
 }
 }
 //8.  Output results
 fmt.Println(&quot;The encryption result is:&quot;, step_move, str_slice_dst, string(str_slice_dst))
 return string(str_slice_dst)
}

3  Caesar password decryption

thought ：

• Set ciphertext and displacement steps

• Prepare ciphertext character slice and plaintext character slice

• The characters of each ciphertext rotate according to the displacement step , And stored in the plaintext slice

• Return clear text

Go  Caesar decrypts the code ：

//2.  Caesar password decryption
func caesarDe(strCipher string, step byte) string {
 //1.  Make text lowercase
 str_cipher := strings.ToLower(strCipher)
 //2.  Alternate step size
 step_move := step
 //3.  Convert a string to a plaintext character slice
 str_slice_src := []byte(str_cipher)
 fmt.Println("Ciphertext character slice:", str_slice_src)

 //4.  Create a ciphertext character slice
 str_slice_dst := str_slice_src

 //5.  Loop through character text slices
 for i := 0; i < len(str_slice_src); i++ {
 //6.  If the plaintext feature of the current period is within the displacement range , Please add a displacement step directly to save the ciphertext character slice
 if str_slice_src[i] >= 97+step_move {
 str_slice_dst[i] = str_slice_src[i] - step_move
 } else { //7.  If plaintext characters are out of range , Then add  26  Step length after subtracting displacement
 str_slice_dst[i] = str_slice_src[i] + 26 - step_move
 }
 }
 //8. Output results
 fmt.Println(&quot;The decryption result is:&quot;, step_move, str_slice_dst, string(str_slice_dst))
 return string(str_slice_dst)
}

4  Other implementations


package main

import (
"errors"
"fmt"
"reflect"
"regexp"
)


var TBL = []rune("abcdefghijklmnopqrstuvwxyz")


var CLUES = []string{"this", "the", "that"}


var (

ErrLength = errors.New("invalid length")

ErrChar = errors.New("invalid char")

ErrNoClue = errors.New("no clue word")

ErrShift = errors.New("invalid shift value")
)




func Encrypt(in string, sh int) (enc string, err error) {
err = assert(in)
if sh < 0 {
err = ErrShift
}
if err != nil {
return
}
enc = shift(in, sh)
return
}



func Decrypt(in string) (dec string, sh int, err error) {

err = assert(in)
if err != nil {
return
}
var hit bool = false 

subin := subStr(in)

for i := 0; i < len(CLUES); i++ {

 subclue := subStr(CLUES[i])

for j := 0; j < len(subin)-len(subclue)+1; j++ {

if reflect.DeepEqual(subin[j:j+1], subclue[0:len(subclue)-1]) {
sh = subtract([]rune(in)[j], []rune(CLUES[i])[0])
hit = true
break
}
}
}

if !hit {
err = ErrNoClue
return
}

dec = shift(in, -sh)
return
}


func assert(in string) (err error) {
if regexp.MustCompile(`[^a-z\. \r\n]`).MatchString(in) {
err = ErrChar
} else if len(in) > 80 {
err = ErrLength
}
return
}


func shift(in string, sh int) (out string) {
for _, v := range in {

if v == '.' || v == ' ' || v == '\r' || v == '\n' {
out += string(v)
continue
}

i := indexOf(TBL, v)

len := len(TBL)
var ii int = (i + sh) % len
if ii < 0 {
ii += len
}
if ii > len {
ii -= len
}
out += string(TBL[ii])
}
return
}


func subtract(left rune, right rune) (out int) {
l := indexOf(TBL, left)
r := indexOf(TBL, right)
out = l - r
if out < 0 {
out += len(TBL)
}
return
}


func subStr(in string) []int { 
subin := make([]int, 0, 79) 
for i := range in {
if i > len(in)-2 {
break
}
subin = append(subin, subtract([]rune(in)[i], []rune(in)[i+1]))
}
// return
return subin
}


func indexOf(target []rune, searchChar rune) int {
for i, v := range target {
if v == searchChar {
return i
}
}
return -1
}

func main() {
in := &quot;xlmw mw xli tmgxyvi xlex m xsso mr xli xvmt.&quot;
fmt.Printf(&quot;in : '%s'\n&quot;, in)
out, sh, err := Decrypt(in)
fmt.Printf(&quot;out: '%s'\n&quot;, out)
fmt.Printf(&quot;sh : %d\n&quot;, sh)
fmt.Printf(&quot;err: %v\n&quot;, err)
}


5  test

package main

import (
"fmt"
"strings"
)

func caesar(r rune, shift int) rune {
// Shift character by specified number of places.
// ... If beyond range, shift backward or forward.
s := int(r) + shift
if s > 'z' {
return rune(s - 26)
} else if s < 'a' {
return rune(s + 26)
}
return rune(s)
}

func main() {
value := &quot;test&quot;
fmt.Println(value)

// Test the caesar method in a func argument to strings.Map.
value2 := strings.Map(func(r rune) rune {
return caesar(r, 18)
}, value)
value3 := strings.Map(func(r rune) rune {
return caesar(r, -18)
}, value2)
fmt.Println(value2, value3)

value4 := strings.Map(func(r rune) rune {
return caesar(r, 1)
}, value)
value5 := strings.Map(func(r rune) rune {
return caesar(r, -1)
}, value4)
fmt.Println(value4, value5)

value = &quot;exxegoexsrgi&quot;
result := strings.Map(func(r rune) rune {
return caesar(r, -4)
}, value)
fmt.Println(value, result)
}


Run the program ：

test
lwkl test
uftu test
exxegoexsrgi attackatonce

6  summary

This paper briefly introduces an interesting Caesar cipher in cryptography , The algorithm is an alternative encryption technology , And in  Go  The code implements the encryption and decryption process of the algorithm .