Go 语言入门很简单：Go 实现凯撒密码

Posted 2022-07-08 宇宙之一粟

在文本上使用凯撒密码来移动字符。调用 ​​strings.Map​​ 方法。

1 凯撒密码加密

凯撒密码（英语：Caesar cipher），或称凯撒加密、凯撒变换、变换加密，是一种最简单且最广为人知的加密技术。

凯撒密码是一种替换加密技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是 3 的时候，所有的字母 A 将被替换成 D；B 变成E，以此类推。这个加密方法是以罗马共和时期凯撒的名字命名的，据称当年凯撒曾用此方法与其将军们进行联系。

明文字母表：ABCDEFGHIJKLMNOPQRSTUVWXYZ 密文字母表：DEFGHIJKLMNOPQRSTUVWXYZABC

设计思想

1. 设置明文和移动步长（秘文）
2. 将清晰的文本转换为小写，准备清晰的文本字节切片和密文切片
3. 每个明文字符根据位移的步长旋转并存储在密文片中
4. 返回密文

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 凯撒密码解密

思想：

1. 设置密文和位移步骤
2. 准备密文字符切片和明文字符切片
3. 每个密文的字符根据位移步长旋转，并存储在明文切片中
4. 返回明文

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(Go 语言入门很简单：什么是上下文

 #私藏项目实操分享#Go 语言入门很简单：Go 如何面向对象
 Go语言入门很简单：如何在 Go 语言中使用 MySQL
 Go 语言入门很简单--技巧和窍门(Tips and Tricks)
 Go 入门很简单：Writer和Reader接口
 Go语言入门篇-gRPC基于golang & java简单实现