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

安全 数据安全
凯撒密码是一种替换加密技术,明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。

在文本上使用凯撒密码来移动字符。调用 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 代码中实现了该算法的加密和解密过程。

责任编辑:武晓燕 来源: 宇宙之一粟
相关推荐

2020-08-12 08:56:30

代码凯撒密码函数

2021-10-28 19:35:48

Go 控制超时

2019-02-11 08:32:22

编程语言Go

2018-03-12 22:13:46

GO语言编程软件

2020-03-17 10:24:12

Go语言停止写障碍

2023-11-25 09:31:20

Go事件管理器

2023-06-10 23:01:41

GrpcProtobuf数据

2022-05-09 10:36:05

PythonPyScript开发者

2022-11-01 18:29:25

Go语言排序算法

2017-11-16 15:25:54

Go语言算法代码

2024-02-06 17:57:06

Go语言任务

2023-05-08 07:55:05

快速排序Go 语言

2022-03-13 23:51:39

Web项目Go

2014-04-24 10:48:27

Go语言基础实现

2012-03-13 10:40:58

Google Go

2015-12-21 14:56:12

Go语言Http网络协议

2022-05-19 14:14:26

go语言限流算法

2012-10-08 09:25:59

GoGo语言开发语言

2010-05-19 16:45:26

MySQL自动启动

2024-04-26 12:56:17

Go编程语言
点赞
收藏

51CTO技术栈公众号