[Quando a inteligência artificial encontra a segurança] 8. Exemplos detalhados de classificação familiar maliciosa com base na sequência de API e aprendizado de máquina

Como você provavelmente sabe, o autor compartilhará cada vez menos artigos sobre segurança de rede no futuro. Mas se você quiser aprender a aplicação de inteligência artificial e segurança, terá benefícios. O autor recriará uma série de blogs "Quando a inteligência artificial encontra a segurança", apresentará detalhadamente os artigos e práticas relacionadas à inteligência artificial e segurança, e compartilhar vários casos envolvendo detecção de código malicioso, identificação de solicitação maliciosa, detecção de intrusão, exemplos adversários, etc. Eu só quero ajudar melhor os iniciantes e compartilhar novos conhecimentos de forma mais sistemática. Esta série de artigos será mais focada, mais acadêmica e mais aprofundada, e é também a história de lento crescimento do autor. Na verdade, é difícil mudar de curso e a segurança do sistema também é um osso duro de roer, mas tentarei ver até onde poderei aprender nos próximos quatro anos. Aproveite o processo, vamos juntos ~

O artigo anterior introduziu conjuntos de dados relacionados à segurança para todos baixarem e experimentarem, incluindo URLs maliciosos, análise de tráfego, detecção de nomes de domínio, malware, classificação de imagens, spam, etc. Este artigo explicará como aprender os recursos extraídos da sequência da API e construir um algoritmo de aprendizado de máquina para classificar famílias maliciosas, o que também é uma tarefa ou trabalho típico na área de segurança. Artigo básico, espero que seja útil para você ~

Como um novato em segurança de rede, o autor compartilha alguns tutoriais básicos de auto-estudo para todos, principalmente notas online, espero que gostem. Ao mesmo tempo, espero que você possa operar e progredir junto comigo.No futuro, aprenderei mais sobre segurança de IA e conhecimento de segurança de sistema e compartilharei experimentos relacionados. Resumindo, espero que esta série de artigos seja útil para blogueiros. Não é fácil escrever artigos. Se você não gosta, não pulverize, obrigado! Se o artigo for útil para você, será a maior motivação para minha criação. Curtidas, comentários e bate-papos privados são aceitáveis. Vamos trabalhar juntos!

Recomendação anterior:

• [Quando a inteligência artificial encontra a segurança] 1. A inteligência artificial é realmente segura? A equipe da Conferência Bund da Universidade de Zhejiang compartilhou IA contra tecnologia de amostra
• [Quando a inteligência artificial encontra a segurança] 2. Professor Zhang Chao da Universidade Tsinghua - GreyOne: Descubra vulnerabilidades com difusão sensível ao fluxo de dados
• [Quando a inteligência artificial encontra a segurança] 3. Aprendizado de máquina no campo da segurança e compartilhamento de casos de identificação de solicitações maliciosas de aprendizado de máquina
• [Quando a inteligência artificial encontra a segurança] 4. Explicação detalhada da tecnologia de detecção de código malicioso baseada em aprendizado de máquina
• [Quando a inteligência artificial encontra a segurança] 5. Pesquisa sobre identificação de código malicioso de host com base em algoritmo de aprendizado de máquina
• [Quando a inteligência artificial encontra a segurança] 6. Detecção de intrusões e identificação de ataques com base em aprendizado de máquina - tomando o conjunto de dados KDD CUP99 como exemplo
• [Quando a inteligência artificial encontra a segurança] 7. Resumo dos conjuntos de dados de segurança baseados em aprendizado de máquina
• [Quando a inteligência artificial encontra a segurança] 8. Exemplos detalhados de classificação familiar maliciosa com base na sequência de API e aprendizado de máquina

Recursos do github do autor:

• https://github.com/eastmountyxz/AI-Security-Paper

---

1. Análise de malware

A análise de malware ou código malicioso geralmente inclui análise estática e análise dinâmica. Os tipos de recursos podem ser divididos em recursos estáticos e recursos dinâmicos, dependendo se o código malicioso está sendo executado no ambiente do usuário ou no ambiente de simulação.

Então, como extrair recursos estáticos ou dinâmicos de malware? Portanto, a primeira parte apresentará brevemente recursos estáticos e dinâmicos.

1. Recursos estáticos

Recursos que realmente não funcionam geralmente incluem:

• bytecódigo: O código binário é convertido em bytecode, um recurso relativamente primitivo sem qualquer processamento
• Tabela IAT: A parte mais importante da estrutura PE, que declara algumas funções e suas localizações, o que é conveniente para importar quando o programa é executado. As tabelas e funções estão relativamente relacionadas
• Tabela de permissões do Android: Se o seu APP declarar algumas permissões que não são utilizadas pelas funções, pode haver propósitos maliciosos, como informações do telefone celular
• caracteres imprimíveis: Converta código binário em código ASCII e execute estatísticas relacionadas
• Bloco de salto de desmontagem IDA: O bloco de salto quando as ferramentas IDA estão depurando e é processado como dados de sequência ou dados de gráfico
• Funções de API comumente usadas
• Imagens de malware

Método de extração de recursos estáticos:

• CAPA
  – https://github.com/mandiant/capa
• IDA Pro
• Sandbox do fornecedor de segurança

---

2. Recursos dinâmicos

Equivalente aos recursos estáticos são mais demorados, eles precisam realmente executar o código. Geralmente inclui:
-Relacionamento de chamada de API: Recursos mais óbvios, quais APIs são chamadas e expressam as funções correspondentes
–gráfico de fluxo de controle: Comumente usado em engenharia de software, o aprendizado de máquina o representa como um vetor de classificação
–Diagrama de fluxo de dados: Comumente usado em engenharia de software, o aprendizado de máquina o representa como um vetor para classificação

Método de extração de recursos dinâmicos:

• Cuco
  – https://github.com/cuckoosandbox/cuckoo
• CAPE
  – https://github.com/kevoreilly/CAPEv2
  – https://capev2.readthedocs.io/en/latest/
• Sandbox do fornecedor de segurança

---

2. Detecção de família maliciosa com base em regressão logística

A série anterior de artigos detalhou como extrair características estáticas e dinâmicas de malware, incluindo sequências de API. A seguir, construiremos um modelo de aprendizado de máquina para aprender sequências de API para obter classificação. O processo básico é o seguinte:

1. Conjunto de dados

Todo o conjunto de dados inclui amostras de 5 tipos de famílias maliciosas, cada amostra passada pelas sequências dinâmicas de API extraídas com sucesso por ferramentas CAPE anteriores. A distribuição dos conjuntos de dados é a seguinte: (os leitores são aconselhados a extrair amostras dos seus próprios conjuntos de dados, incluindo BIG2015, BODMAS, etc.)

família maliciosa	categoria	quantidade	Conjunto de treinamento	Conjunto de teste
AAAA	classe 1	352	242	110
BBB	classe2	335	235	100
CCCC	classe3	363	243	120
DDDD	classe4	293	163	130
EEEE	classe5	548	358	190

O conjunto de dados é dividido em conjunto de treinamento e conjunto de teste, conforme mostrado na figura a seguir:

O conjunto de dados inclui principalmente quatro campos, nomeadamente número de série, categoria de família maliciosa, valor Md5, sequência ou recurso de API.

Deve-se notar que o processo de extração de características envolve uma grande quantidade de trabalho de pré-processamento e limpeza de dados, e os leitores precisam concluí-lo de acordo com as necessidades reais. Por exemplo, filtre o código que extrai recursos que são valores nulos.

#coding:utf-8
#By:Eastmount CSDN 2023-05-31
import csv
import re
import os

csv.field_size_limit(500 * 1024 * 1024)
filename = "AAAA_result.csv"
writename = "AAAA_result_final.csv"
fw = open(writename, mode="w", newline="")
writer = csv.writer(fw)
writer.writerow(['no', 'type', 'md5', 'api'])
with open(filename,encoding='utf-8') as fr:
    reader = csv.reader(fr)
    no = 1
    for row in reader: #['no','type','md5','api']
        tt = row[1]
        md5 = row[2]
        api = row[3]
        #print(no,tt,md5,api)
        #api空值的过滤
        if api=="" or api=="api":
            continue
        else:
            writer.writerow([str(no),tt,md5,api])
            no += 1
fr.close()

---

2. Construção do modelo

Como o algoritmo de aprendizado de máquina é relativamente simples, apenas os códigos-chave são fornecidos aqui. Além disso, as representações de recursos comumente usadas incluem TF-IDF e Word2Vec. Aqui, TF-IDF é usado para calcular o vetor de recursos. Os leitores podem tentar o Word2Vec para finalmente obter a classificação familiar e obter um valor Acc de 0,6215.

# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2023-06-01
import os
import csv
import time
import numpy as np
import seaborn as sns
from sklearn import metrics
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

start = time.clock()
csv.field_size_limit(500 * 1024 * 1024)

#---------------------------第一步 加载数据集------------------------
#训练集
file = "train_dataset.csv"
label_train = []
content_train = []
with open(file, "r") as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)
    for row in csv_reader:
        label_train.append(row[1])
        value = str(row[3])
        content_train.append(value)
print(label_train[:2])
print(content_train[:2])

#测试集
file = "test_dataset.csv"
label_test = []
content_test = []
with open(file, "r") as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)
    for row in csv_reader:
        label_test.append(row[1])
        value = str(row[3])
        content_test.append(value)
print(len(label_train),len(label_test))
print(len(content_train),len(content_test)) #1241 650

#---------------------------第二步 向量转换------------------------
contents = content_train + content_test
labels = label_train + label_test

#计算词频 min_df max_df
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(contents)
words = vectorizer.get_feature_names()
print(words[:10])
print("特征词数量:",len(words))

#计算TF-IDF
transformer = TfidfTransformer()
tfidf = transformer.fit_transform(X)
weights = tfidf.toarray()

#---------------------------第三步 编码转换------------------------
le = LabelEncoder()
y = le.fit_transform(labels)
X_train, X_test = weights[:1241], weights[1241:]
y_train, y_test = y[:1241], y[1241:]

#---------------------------第四步 分类检测------------------------
clf = LogisticRegression(solver='liblinear')
clf.fit(X_train, y_train)
pre = clf.predict(X_test)
print(clf)
print(classification_report(y_test, pre, digits=4))
print("accuracy:")
print(metrics.accuracy_score(y_test, pre))

#计算时间
elapsed = (time.clock() - start)
print("Time used:", elapsed)

O resultado de saída é mostrado na figura abaixo:

1241 650
1241 650
['__anomaly__', 'accept', 'bind', 'changewindowmessagefilter', 'closesocket', 'clsidfromprogid', 'cocreateinstance', 'cocreateinstanceex', 'cogetclassobject', 'colescript_parsescripttext']
特征词数量: 269
LogisticRegression(solver='liblinear')
              precision    recall  f1-score   support

           0     0.5398    0.5545    0.5471       110
           1     0.6526    0.6200    0.6359       100
           2     0.6596    0.5167    0.5794       120
           3     0.8235    0.5385    0.6512       130
           4     0.5665    0.7842    0.6578       190

    accuracy                         0.6215       650
   macro avg     0.6484    0.6028    0.6143       650
weighted avg     0.6438    0.6215    0.6199       650

accuracy:
0.6215384615384615
Time used: 2.2597622

---

3. Detecção de família maliciosa baseada em SVM

1. Modelo SVM

A ideia central do algoritmo de classificação SVM é encontrar um hiperplano que atenda aos requisitos de classificação em grandes dimensões, estabelecendo uma determinada função de kernel, de modo que os pontos no conjunto de treinamento estejam o mais distantes possível da superfície de classificação, que é encontrar uma superfície de classificação que faça com que seus dois lados O espaço em branco seja o maior. Conforme mostrado na Figura 19.16, as amostras de treinamento no hiperplano que está mais próximo da superfície de classificação e paralela à superfície de classificação ideal entre os dois tipos de amostras são chamadas de vetores de suporte.

O algoritmo de classificação SVM é implementado no pacote de aprendizado de máquina Sklearn svm.SVC, ou seja, C-Support Vector Classification, que é implementado com base em libsvm. O método de construção é o seguinte:

SVC(C=1.0, 
	cache_size=200, 
	class_weight=None, 
	coef0=0.0,
	decision_function_shape=None, 
	degree=3, 
	gamma='auto', 
	kernel='rbf',
	max_iter=-1, 
	probability=False, 
	random_state=None, 
	shrinking=True,
	tol=0.001, 
	verbose=False)

O algoritmo SVC inclui principalmente duas etapas:

• treinamento :nbrs.fit(data, target)
• Previsão :pre = clf.predict(data)

---

2. Implementação de código

A seguir é fornecido apenas o código-chave do SVM para realizar a classificação de famílias maliciosas.Este algoritmo também é um modelo comumente usado em várias tarefas de segurança. Deve-se notar que os resultados da previsão são salvos em um arquivo aqui.No experimento real, é recomendável salvar mais dados do processo experimental, para que você possa comparar melhor os vários desempenhos e refletir a contribuição do papel.

# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2023-06-01
import os
import csv
import time
import numpy as np
import seaborn as sns
from sklearn import svm
from sklearn import metrics
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

start = time.clock()
csv.field_size_limit(500 * 1024 * 1024)

#---------------------------第一步 加载数据集------------------------
#训练集
file = "train_dataset.csv"
label_train = []
content_train = []
with open(file, "r") as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)
    for row in csv_reader:
        label_train.append(row[1])
        value = str(row[3])
        content_train.append(value)
print(label_train[:2])
print(content_train[:2])

#测试集
file = "test_dataset.csv"
label_test = []
content_test = []
with open(file, "r") as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)
    for row in csv_reader:
        label_test.append(row[1])
        value = str(row[3])
        content_test.append(value)
print(len(label_train),len(label_test))
print(len(content_train),len(content_test)) #1241 650

#---------------------------第二步 向量转换------------------------
contents = content_train + content_test
labels = label_train + label_test

#计算词频 min_df max_df
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(contents)
words = vectorizer.get_feature_names()
print(words[:10])
print("特征词数量:",len(words))

#计算TF-IDF
transformer = TfidfTransformer()
tfidf = transformer.fit_transform(X)
weights = tfidf.toarray()

#---------------------------第三步 编码转换------------------------
le = LabelEncoder()
y = le.fit_transform(labels)
X_train, X_test = weights[:1241], weights[1241:]
y_train, y_test = y[:1241], y[1241:]

#---------------------------第四步 分类检测------------------------
clf = svm.LinearSVC()
clf.fit(X_train, y_train)
pre = clf.predict(X_test)
print(clf)
print(classification_report(y_test, pre, digits=4))
print("accuracy:")
print(metrics.accuracy_score(y_test, pre))

#结果存储
f1 = open("svm_test_pre.txt", "w")
for n in pre:
    f1.write(str(n) + "\n")
f1.close()

f2 = open("svm_test_y.txt", "w")
for n in y_test:
    f2.write(str(n) + "\n")
f2.close()

#计算时间
elapsed = (time.clock() - start)
print("Time used:", elapsed)

Os resultados experimentais são mostrados na figura abaixo:

1241 650
1241 650

['__anomaly__', 'accept', 'bind', 'changewindowmessagefilter', 'closesocket', 'clsidfromprogid', 'cocreateinstance', 'cocreateinstanceex', 'cogetclassobject', 'colescript_parsescripttext']
特征词数量: 269
LinearSVC()
              precision    recall  f1-score   support

           0     0.6439    0.7727    0.7025       110
           1     0.8780    0.7200    0.7912       100
           2     0.7315    0.6583    0.6930       120
           3     0.9091    0.6154    0.7339       130
           4     0.6583    0.8316    0.7349       190

    accuracy                         0.7292       650
   macro avg     0.7642    0.7196    0.7311       650
weighted avg     0.7534    0.7292    0.7301       650

accuracy:
0.7292307692307692
Time used: 2.2672032

---

4. Detecção de família maliciosa com base em floresta aleatória

O código-chave desta parte é o seguinte e o código de análise visual é complementado.

# -*- coding: utf-8 -*-
# By:Eastmount CSDN 2023-06-01
import os
import csv
import time
import numpy as np
import seaborn as sns
from sklearn import svm
from sklearn import metrics
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

start = time.clock()
csv.field_size_limit(500 * 1024 * 1024)

#---------------------------第一步 加载数据集------------------------
#训练集
file = "train_dataset.csv"
label_train = []
content_train = []
with open(file, "r") as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)
    for row in csv_reader:
        label_train.append(row[1])
        value = str(row[3])
        content_train.append(value)
print(label_train[:2])
print(content_train[:2])

#测试集
file = "test_dataset.csv"
label_test = []
content_test = []
with open(file, "r") as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)
    for row in csv_reader:
        label_test.append(row[1])
        value = str(row[3])
        content_test.append(value)
print(len(label_train),len(label_test))
print(len(content_train),len(content_test)) #1241 650

#---------------------------第二步 向量转换------------------------
contents = content_train + content_test
labels = label_train + label_test

#计算词频 min_df max_df
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(contents)
words = vectorizer.get_feature_names()
print(words[:10])
print("特征词数量:",len(words))

#计算TF-IDF
transformer = TfidfTransformer()
tfidf = transformer.fit_transform(X)
weights = tfidf.toarray()

#---------------------------第三步 编码转换------------------------
le = LabelEncoder()
y = le.fit_transform(labels)
X_train, X_test = weights[:1241], weights[1241:]
y_train, y_test = y[:1241], y[1241:]

#---------------------------第四步 分类检测------------------------
clf = RandomForestClassifier(n_estimators=5)
clf.fit(X_train, y_train)
pre = clf.predict(X_test)
print(clf)
print(classification_report(y_test, pre, digits=4))
print("accuracy:")
print(metrics.accuracy_score(y_test, pre))

#结果存储
f1 = open("rf_test_pre.txt", "w")
for n in pre:
    f1.write(str(n) + "\n")
f1.close()

f2 = open("rf_test_y.txt", "w")
for n in y_test:
    f2.write(str(n) + "\n")
f2.close()

#计算时间
elapsed = (time.clock() - start)
print("Time used:", elapsed)

#---------------------------第五步 可视化分析------------------------
#降维
pca = PCA(n_components=2)
pca = pca.fit(X_test)
xx = pca.transform(X_test)

#画图
plt.figure()
plt.scatter(xx[:,0],xx[:,1],c=y_test, s=50)
plt.title("Malware Family Detection")
plt.show()

O resultado da saída é o seguinte, o efeito atingiu 0,8092, o que é muito bom.

1241 650
1241 650
['__anomaly__', 'accept', 'bind', 'changewindowmessagefilter', 'closesocket', 'clsidfromprogid', 'cocreateinstance', 'cocreateinstanceex', 'cogetclassobject', 'colescript_parsescripttext']
特征词数量: 269
RandomForestClassifier(n_estimators=5)
              precision    recall  f1-score   support

           0     0.7185    0.8818    0.7918       110
           1     0.9000    0.8100    0.8526       100
           2     0.7963    0.7167    0.7544       120
           3     0.9444    0.7846    0.8571       130
           4     0.7656    0.8421    0.8020       190

    accuracy                         0.8092       650
   macro avg     0.8250    0.8070    0.8116       650
weighted avg     0.8197    0.8092    0.8103       650

accuracy:
0.8092307692307692
Time used: 2.1914324

Ao mesmo tempo, cinco tipos de famílias maliciosas são analisados ​​visualmente. No entanto, o efeito geral é medíocre. É necessário otimizar ainda mais o código e a dimensão para distinguir conjuntos de dados ou gráficos de dispersão 3D. Os leitores são convidados a pensar por si próprios.

---

5. Resumo

Este é o final deste artigo, espero que seja útil para você. Maio ocupado, muito ocupado. Depois de terminar a tese do projeto, escreverei alguns blogs de segurança depois de terminar meu trabalho. Obrigado pelo seu apoio e companhia, especialmente pelo incentivo e apoio de sua família. Continue!

• 1. Análise de malware
  1. Recursos estáticos
  2. Recursos dinâmicos
• 2. Detecção de famílias mal-intencionadas com base em regressão logística
  1. Conjunto de dados
  2. Construção de modelo
• 3. Detecção de família maliciosa baseada em SVM
  1. Modelo SVM
  2. Implementação de código
• 4. Detecção de família maliciosa com base em floresta aleatória
• 5. Resumo

O autor faz as seguintes perguntas, bem-vindo para acrescentar:

• Quais são as características comuns de malware ou binários? Quais são as vantagens e desvantagens de cada um.
• O malware para imagens em escala de cinza é um método comum de classificação familiar. Quais são suas vantagens e desvantagens em comparação com o método proposto neste artigo?
• Como extrair malware CFG e ICFG? Como pode ser aprendido pelo modelo de aprendizado de máquina após a extração?
• Quais são os métodos comuns de representação vetorial e quais são suas características? Você pode implementar o código para Word2Vec?
• Qual é a conexão e a diferença entre aprendizado de máquina e aprendizado profundo? Se um modelo de aprendizagem profunda for construído para aprender sequências de API, quão eficaz será a detecção de famílias maliciosas?
• Onde está o estado atual da classificação da família de malware ou da detecção de códigos maliciosos? Quais são as características e limitações da indústria e da academia e como se conectar melhor para promover o desenvolvimento da área?
• Existe uma maneira melhor de inovar ou romper a direção binária? Como melhorar sua robustez, aprimoramento semântico e interpretabilidade.
• Como detectar malware de famílias desconhecidas e como rastrear a origem do malware de alta ameaça?
• Como a detecção de malware se integra melhor ao hardware e aos compiladores subjacentes? E como combater as variantes, o ofuscamento e o confronto.
• A detecção de malware pode gerar variantes rapidamente por meio da tecnologia chatGPT? E como combater o desenvolvimento desta tecnologia.

A estrada da vida é feita de encruzilhadas, jogo após jogo, complicações e ganhos e perdas. Ganhos e perdas, ganhos e perdas, escolhas diferentes, emoções diferentes. Embora cansado e ocupado, ver Xiao Luoluo é bastante gratificante e agradeço à minha família pela companhia.
Xiao Luo: Pai, você voltou do trabalho.
Eu: Você chorou no supermercado com sua sogra hoje?
Xiao Luo: Sim, eu quero levar o bolinho de cabelo sozinho
Eu: Ouvi dizer que o vovô e a vovó riram de mim, de agora em diante...
Xiao Luo: Qual a utilidade deles rirem!

Sim, haha, de que adianta? O pequeno Luoluo cresceu, e a fofinha se tornou um pouco safada. Recentemente, estou relutante em pegar um táxi, pegar um ônibus e compartilhar uma motocicleta, mas também confio na compra de bilhetes de loteria.Nossas 5 milhões de palavras, por que não segui a deusa para comprar uma casa em nossa comunidade em 2017 ? Neste ano, sinto que posso ganhar quase 1 milhão de yuans, o que é suficiente para lecionar em Guizhou por dez anos. É tudo um jogo, é tudo uma escolha, é tudo doce e azedo, espero que Xiaoluo possa crescer feliz e saudável, eu te amo, continue trabalhando, vamos lá

(Por:Eastmount 2023-09-06 noite em Guiyang http://blog.csdn.net/eastmount/ )