Go實現凱撒密碼加密解密

2022-08-02 14:04:23

1 凱撒密碼加密

凱撒密碼（英語：Caesar cipher），或稱凱撒加密、凱撒變換、變換加密，是一種最簡單且最廣為人知的加密技術。

凱撒密碼是一種替換加密技術，明文中的所有字母都在字母表上向後（或向前）按照一個固定數目進行偏移後被替換成密文。

例如，當偏移量是 3 的時候，所有的字母 A 將被替換成 D；B 變成E，以此類推。這個加密方法是以羅馬共和時期凱撒的名字命名的，據稱當年凱撒曾用此方法與其將軍們進行聯絡。

在文字上使用凱撒密碼來移動字元。呼叫 strings.Map 方法。

明文字母表：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. rn]`).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 : %dn", sh)
	fmt.Printf("err: %vn", 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 &gt; 'z' {
		return rune(s - 26)
	} else if s &lt; '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)
}

執行該程式：