日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

在文本上使用凱撒密碼來(lái)移動(dòng)字符。調(diào)用 strings.Map 方法。

網(wǎng)站制作、做網(wǎng)站服務(wù)團(tuán)隊(duì)是一支充滿(mǎn)著熱情的團(tuán)隊(duì)，執(zhí)著、敏銳、追求更好，是創(chuàng)新互聯(lián)的標(biāo)準(zhǔn)與要求，同時(shí)竭誠(chéng)為客戶(hù)提供服務(wù)是我們的理念。成都創(chuàng)新互聯(lián)公司把每個(gè)網(wǎng)站當(dāng)做一個(gè)產(chǎn)品來(lái)開(kāi)發(fā)，精雕細(xì)琢，追求一名工匠心中的細(xì)致，我們更用心！

1.凱撒密碼加密

凱撒密碼（英語(yǔ)：Caesar cipher），或稱(chēng)凱撒加密、凱撒變換、變換加密，是一種最簡(jiǎn)單且最廣為人知的加密技術(shù)。

凱撒密碼是一種替換加密技術(shù)，明文中的所有字母都在字母表上向后（或向前）按照一個(gè)固定數(shù)目進(jìn)行偏移后被替換成密文。例如，當(dāng)偏移量是 3 的時(shí)候，所有的字母 A 將被替換成 D；B 變成E，以此類(lèi)推。這個(gè)加密方法是以羅馬共和時(shí)期凱撒的名字命名的，據(jù)稱(chēng)當(dāng)年凱撒曾用此方法與其將軍們進(jìn)行聯(lián)系。

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

設(shè)計(jì)思想

• 設(shè)置明文和移動(dòng)步長(zhǎng)（秘文）
• 將清晰的文本轉(zhuǎn)換為小寫(xiě)，準(zhǔn)備清晰的文本字節(jié)切片和密文切片
• 每個(gè)明文字符根據(jù)位移的步長(zhǎng)旋轉(zhuǎn)并存儲(chǔ)在密文片中
• 返回密文

2.Go實(shí)現(xiàn)

凱撒密碼一般以密碼形式交付。比如這串代碼“exxegoexsrgi”是密碼。

通過(guò)移動(dòng)字母，我們可以對(duì)消息進(jìn)行編碼。這阻止了隨意的窺探。在 Go 中，我們可以使用 strings.Map 方法來(lái)實(shí)現(xiàn)這一點(diǎn)。

2.1 導(dǎo)入包

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

2.2 編寫(xiě) caesar 方法

然后讓我們來(lái)編寫(xiě) caesarEn() 凱撒密碼加密方法。這會(huì)接收一個(gè)字符串并返回一個(gè)修改過(guò)的字符串。

它會(huì)移動(dòng)字符，然后將字符移動(dòng)到有效范圍。

// 凱撒密碼加密
func caesarEn(strRaw string, step byte) string {
    //1. 將文本轉(zhuǎn)為小寫(xiě)
    str_raw := strings.ToLower(strRaw)
    //2. 定義步長(zhǎng)
    step_move := step
    //3. 將字符串轉(zhuǎn)換為明文字符切片
    str_slice_src := []byte(str_raw)
    fmt.Println("Clear text character slice:", str_slice_src)

    //4. 創(chuàng)建一個(gè)密文字符切片
    str_slice_dst := str_slice_src

    //5.循環(huán)處理文本切片
    for i := 0; i < len(str_slice_src); i++ {
        //6.如果當(dāng)前周期的明文特征在位移范圍內(nèi)，請(qǐng)直接添加位移步驟以保存密文字符切片
        if str_slice_src[i] < 123-step_move {
            str_slice_dst[i] = str_slice_src[i] + step_move
        } else { //7. 如果明文字符超出范圍，則加上位移后的步長(zhǎng)減去 26
            str_slice_dst[i] = str_slice_src[i] + step_move - 26
        }
    }
    //8. 輸出結(jié)果
    fmt.Println("The encryption result is:", step_move, str_slice_dst, string(str_slice_dst))
    return string(str_slice_dst)
}

3.凱撒密碼解密

思想：

• 設(shè)置密文和位移步驟
• 準(zhǔn)備密文字符切片和明文字符切片
• 每個(gè)密文的字符根據(jù)位移步長(zhǎng)旋轉(zhuǎn)，并存儲(chǔ)在明文切片中
• 返回明文

Go 凱撒解密代碼：

//2. 凱撒密碼解密
func caesarDe(strCipher string, step byte) string {
    //1. 將文本轉(zhuǎn)為小寫(xiě)
    str_cipher := strings.ToLower(strCipher)
    //2. 替代步長(zhǎng)
    step_move := step
    //3. 將字符串轉(zhuǎn)換為明文字符切片
    str_slice_src := []byte(str_cipher)
    fmt.Println("Ciphertext character slice:", str_slice_src)

    //4. 創(chuàng)建一個(gè)密文字符切片
    str_slice_dst := str_slice_src

    //5. 循環(huán)處理字符文本切片
    for i := 0; i < len(str_slice_src); i++ {
        //6. 如果當(dāng)前周期的明文特征在位移范圍內(nèi)，請(qǐng)直接添加位移步驟以保存密文字符切片
        if str_slice_src[i] >= 97+step_move {
            str_slice_dst[i] = str_slice_src[i] - step_move
        } else { //7. 如果明文字符超出范圍，則加上 26 減去位移后的步長(zhǎng)
            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.其他實(shí)現(xiàn)

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.測(cè)試

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)
}

運(yùn)行該程序：

test
lwkl test
uftu test
exxegoexsrgi attackatonce

6.總結(jié)

本文簡(jiǎn)單介紹了一個(gè)有意思的密碼學(xué)中的凱撒密碼，該算法是一種替換加密技術(shù)，并在 Go 代碼中實(shí)現(xiàn)了該算法的加密和解密過(guò)程。

本文名稱(chēng)：Go 語(yǔ)言入門(mén)很簡(jiǎn)單：Go 實(shí)現(xiàn)凱撒密碼
標(biāo)題路徑：http://www.5511xx.com/article/codsiij.html