在文本上使用凱撒密碼來移動字符。調用 strings.Map 方法。
1.凱撒密碼加密
凱撒密碼（英語：Caesar cipher），或稱凱撒加密、凱撒變換、變換加密，是一種最簡單且最廣為人知的加密技術。
凱撒密碼是一種替換加密技術，明文中的所有字母都在字母表上向后（或向前）按照一個固定數目進行偏移后被替換成密文。例如，當偏移量是 3 的時候，所有的字母 A 將被替換成 D；B 變成E，以此類推。這個加密方法是以羅馬共和時期凱撒的名字命名的，據稱當年凱撒曾用此方法與其將軍們進行聯系。
- 明文字母表：ABCDEFGHIJKLMNOPQRSTUVWXYZ
- 密文字母表：DEFGHIJKLMNOPQRSTUVWXYZABC
設計思想
- 設置明文和移動步長（秘文）
- 將清晰的文本轉換為小寫，準備清晰的文本字節切片和密文切片
- 每個明文字符根據位移的步長旋轉并存儲在密文片中
- 返回密文
2.Go實現
凱撒密碼一般以密碼形式交付。比如這串代碼“exxegoexsrgi”是密碼。
通過移動字母，我們可以對消息進行編碼。這阻止了隨意的窺探。在 Go 中，我們可以使用 strings.Map 方法來實現這一點。
2.1 導入包
import (
"fmt"
"strings" // Include string operation related methods
)
2.2 編寫 caesar 方法
然后讓我們來編寫 caesarEn() 凱撒密碼加密方法。這會接收一個字符串并返回一個修改過的字符串。
它會移動字符，然后將字符移動到有效范圍。
// 凱撒密碼加密
func caesarEn(strRaw string, step byte) string {
//1. 將文本轉為小寫
str_raw := strings.ToLower(strRaw)
//2. 定義步長
step_move := step
//3. 將字符串轉換為明文字符切片
str_slice_src := []byte(str_raw)
fmt.Println("Clear text character slice:", str_slice_src)
//4. 創建一個密文字符切片
str_slice_dst := str_slice_src
//5.循環處理文本切片
for i := 0; i < len(str_slice_src); i++ {
//6.如果當前周期的明文特征在位移范圍內，請直接添加位移步驟以保存密文字符切片
if str_slice_src[i] < 123-step_move {
str_slice_dst[i] = str_slice_src[i] + step_move
} else { //7. 如果明文字符超出范圍，則加上位移后的步長減去 26
str_slice_dst[i] = str_slice_src[i] + step_move - 26
}
}
//8. 輸出結果
fmt.Println("The encryption result is:", step_move, str_slice_dst, string(str_slice_dst))
return string(str_slice_dst)
}
3.凱撒密碼解密
思想：
- 設置密文和位移步驟
- 準備密文字符切片和明文字符切片
- 每個密文的字符根據位移步長旋轉，并存儲在明文切片中
- 返回明文
Go 凱撒解密代碼：
//2. 凱撒密碼解密
func caesarDe(strCipher string, step byte) string {
//1. 將文本轉為小寫
str_cipher := strings.ToLower(strCipher)
//2. 替代步長
step_move := step
//3. 將字符串轉換為明文字符切片
str_slice_src := []byte(str_cipher)
fmt.Println("Ciphertext character slice:", str_slice_src)
//4. 創建一個密文字符切片
str_slice_dst := str_slice_src
//5. 循環處理字符文本切片
for i := 0; i < len(str_slice_src); i++ {
//6. 如果當前周期的明文特征在位移范圍內，請直接添加位移步驟以保存密文字符切片
if str_slice_src[i] >= 97+step_move {
str_slice_dst[i] = str_slice_src[i] - step_move
} else { //7. 如果明文字符超出范圍，則加上 26 減去位移后的步長
str_slice_dst[i] = str_slice_src[i] + 26 - step_move
}
}
//8. Output results
fmt.Println("The decryption result is:", step_move, str_slice_dst, string(str_slice_dst))
return string(str_slice_dst)
}
4.其他實現
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 := "xlmw mw xli tmgxyvi xlex m xsso mr xli xvmt."
fmt.Printf("in : '%s'\n", in)
out, sh, err := Decrypt(in)
fmt.Printf("out: '%s'\n", out)
fmt.Printf("sh : %d\n", sh)
fmt.Printf("err: %v\n", err)
}
5.測試
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 := "test"
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 = "exxegoexsrgi"
result := strings.Map(func(r rune) rune {
return caesar(r, -4)
}, value)
fmt.Println(value, result)
}
運行該程序：
test
lwkl test
uftu test
exxegoexsrgi attackatonce
6.總結
本文簡單介紹了一個有意思的密碼學中的凱撒密碼，該算法是一種替換加密技術，并在 Go 代碼中實現了該算法的加密和解密過程。
