Gere o endereço do Gmail usando C++
Crie seu próprio gerador temporário do Gmail com senha usando C ++
Download grátis julgamento
O gerador do Gmail é uma forma bastante comum de gerenciar assinaturas de e-mail. Em essência, isso é um análogo de um provedor de endereços de e-mail temporários, mas muito mais flexível, confiável e seguro.
A essência do gerador é criar endereços adicionais do Gmail. Você pode usar esses endereços adicionais ao se registrar em vários sites. Esses sites provavelmente enviarão e-mails para os endereços que você fornecer. Como os endereços são adicionais, todas as cartas irão para o seu endereço principal. Mas, ao mesmo tempo, um endereço adicional gerado pelo aplicativo ou preparado manualmente será indicado como o destinatário da carta.
Pesquisar e-mails pelo endereço do destinatário permitirá que você filtre e-mails e execute ações automáticas neles. Uma vez ou permanente. Você também pode capturar sites que compartilham seu endereço com terceiros sem o seu consentimento.
Por exemplo, digamos que você tenha gerado um endereço adicional username+ for.spam.sender@gmail.com . Em seguida, você o passou para o site spam-sender.com. Depois de algum tempo, você poderá receber um e-mail de algum outro site, como other-sender.com, mas o destinatário será username+ for.spam.sender@gmail.com . Em qualquer outra situação, você não conseguiria descobrir por que other-sender.com está enviando e-mails promocionais, mas como você usou um endereço alternativo, é fácil ver que spam-sender.com compartilhou seu endereço com terceiros. E nesse caso, não faz sentido cancelar a inscrição nas listas de e-mail desses sites. Seu endereço adicional provavelmente já foi incluído em alguma base pública para envio de e-mails indesejados. Será muito mais fácil se você bloquear todos os e-mails que chegam a esse endereço adicional. Seria ainda melhor se você configurasse o movimento automático desses e-mails para a pasta de spam. Essa configuração dificultará muito a vida desses sites, pois o Gmail saberá que esses sites estão enviando spam.
Então, vamos descobrir como implementar esse gerador usando Aspose.Email para C++.
Gere o Gmail temporário e opere com ele
Para gerar um endereço adicional do Gmail, na verdade não precisamos do Aspose.Email, não precisamos interagir com o serviço do Gmail de forma alguma. Qualquer endereço adicional que você criar manual ou aleatoriamente, sujeito a determinadas regras, funcionará.
Então, quais são essas regras?
Os pontos não são importantes. Ou seja, no seu endereço, antes do símbolo ‘@’, você pode remover pontos e adicionar novos entre quaisquer pares de letras.
Antes do caractere ‘@’, você pode adicionar um caractere ‘+’ com qualquer conjunto de letras e números depois dele. Exemplos para o endereço “username@gmail.com”:
Todos esses endereços já podem ser usados ao se cadastrar em sites. Mas, sozinhos, eles fazem pouco sentido, porque todas as mensagens que chegam a esses endereços acabarão na sua caixa de correio principal. Portanto, vale a pena usar nossas instruções para trabalhar com esses endereços.
Gerador simples de Gmail temporário
Então, vamos criar um gerador de subendereços aleatórios simples. Para fazer isso, adicionaremos uma string aleatória entre os caracteres ‘+’ e ‘@ ‘. Primeiro de tudo, precisamos gerar uma string aleatória de um determinado tamanho, consistindo em um determinado conjunto de caracteres:
const char16_t pattern[] = u"abcdefghijklmnopqrstuvwxyz0123456789";
auto patternLength = std::char_traits<char16_t>::length(pattern);
const int suffixLength = 10;
std::string generatedSuffix;
generatedSuffix.reserve(suffixLength);
srand(time(NULL));
for (int i = 0; i < suffixLength; i++)
{
generatedSuffix += pattern[rand() % (patternLength - 1)];
}
Agora precisamos obter o endereço de e-mail e adicionar a string aleatória gerada a ele. Para fazer isso, usaremos o MailAdress classe da biblioteca Aspose.Email para C++:
auto originalAddress = System::MakeObject<MailAddress>(System::String(u"some.address@gmail.com"));
auto generatedAddress = System::MakeObject<MailAddress>(
originalAddress->get_User() + u"+" + generatedSuffix + u"@" + originalAddress->get_Host());
Console::WriteLine(generatedAddress);
Feito! O endereço recebido já pode ser usado ao se registrar em sites. Em breve, os sites começarão a enviar mensagens para esse endereço. Vamos ver o que podemos fazer com essas mensagens.
Use o cliente IMAP para operar com as mensagens recebidas no Gmail gerado
Primeiro, para operar as mensagens recebidas em um endereço adicional, precisamos nos conectar ao Gmail. O IMAP é adequado para isso. Para se conectar usando esse protocolo, não se esqueça de configurar sua conta para permitir a conexão com ela usando esse protocolo. Além disso, você pode simplificar a conexão IMAP com uma senha de aplicativo dedicada. Isso permitirá que você evite a necessidade de realizar a autorização do OAuth se não quiser implementá-la em seu aplicativo. Basta acessar as configurações da sua conta do Google, abrir a seção Segurança e adicionar uma senha de aplicativo. Não se esqueça de salvar a senha gerada em um armazenamento seguro e tente não perdê-la, pois ela oferece acesso total ao seu e-mail!
Então, vamos usar o ImapClient classifique e conecte-se à sua conta do Gmail usando o protocolo IMAP:
auto imapClient = System::MakeObject<Clients::Imap::ImapClient>(
u"imap.gmail.com", 993, originalAddress->get_User(), u"password",
SecurityOptions::SSLAuto);
Pronto, agora podemos, por exemplo, obter todas as mensagens recebidas no endereço do Gmail gerado:
imapClient->SelectFolder(u"INBOX");
auto queryBuilder = System::MakeObject<ImapQueryBuilder>();
queryBuilder->get_To()->Contains(generatedAddress->get_Address());
auto list = imapClient->ListMessages(queryBuilder->GetQuery());
E você receberá absolutamente todas essas cartas. Não importa de qual site eles vieram até você. Eles podem ter vindo do site ao qual você forneceu o endereço de e-mail gerado. Pode ter vindo de outro site. De qualquer endereço. Analisamos os e-mails não pelo remetente, mas pelo destinatário. E é muito conveniente.
Marque, remova e mova as mensagens recebidas para o Gmail temporário
Depois de receber a lista de cartas, já podemos realizar várias operações nela. Acima de tudo de uma vez. Você não precisa encontrá-los na sua caixa de correio, um por um. Literalmente, alguns comandos e todas as letras são marcados como lidos, movidos para outra pasta ou simplesmente excluídos. Só não se esqueça de verificar com antecedência se a lista de letras não está vazia. Talvez você já tenha excluído tudo.
if (list->get_Count() > 0)
{
//Mark as read
imapClient->AddMessageFlags(list, ImapMessageFlags::get_IsRead());
//Move
imapClient->MoveMessages(list, u"DestinationFolder");
//Remove
imapClient->DeleteMessages(list, true);
}
Pronto, sua caixa de entrada foi limpa de spam.
Inscreva-se no endereço temporário do Gmail
E se você não quiser excluir ou sinalizar e-mails constantemente chamando manualmente o código acima? E se você quiser excluir e-mails assim que eles forem recebidos? Para fazer isso, por exemplo, você pode se inscrever em novas mensagens e escrever uma função que exclua as mensagens assim que elas chegarem ao seu endereço de e-mail.
std::function<void(System::SharedPtr<System::Object> sender, System::SharedPtr<Clients::Imap::ImapMonitoringEventArgs> eventArgs)> subscribeCallback =
[&generatedAddress, &imapClient](System::SharedPtr<System::Object> sender, System::SharedPtr<ImapMonitoringEventArgs> eventArgs)
{
auto newMessages = eventArgs->get_NewMessages();
auto generated = System::MakeObject<ImapMessageInfoCollection>();
for each (auto newMessage in newMessages)
{
for each (auto address in newMessage->get_To())
{
if (address->get_Address() == generatedAddress->get_Address())
{
generated->Add(newMessage);
break;
}
}
}
if (generated->get_Count() == 0) return;
imapClient->SelectFolder(u"INBOX");
//Do something with the received messages. For example, mark them as read:
imapClient->AddMessageFlags(generated, ImapMessageFlags::get_IsRead());
//or delete them
imapClient->DeleteMessages(generated, true);
};
std::function<void(System::SharedPtr<System::Object> sender, System::SharedPtr<Clients::Imap::ImapMonitoringErrorEventArgs> eventArgs)> errorCallback =
[](System::SharedPtr<System::Object> _, System::SharedPtr<ImapMonitoringErrorEventArgs> errorEventArgs)
{
Console::WriteLine(errorEventArgs->get_Error()->get_Message());
};
imapClient->StartMonitoring(subscribeCallback, errorCallback, u"INBOX");
Esse algoritmo é um pouco simplificado porque, em caso de erro, a assinatura de novas mensagens será interrompida. Você pode melhorar muito o algoritmo. Para fazer isso, você precisa refinar o algoritmo melhorando o tratamento de erros. Por exemplo, você pode configurar a retomada do monitoramento em caso de erro, para isso, você pode usar a função IMAPClient.resumeMonitoring. Essa função restabelecerá a conexão com o servidor IMAP e retomará o monitoramento de novas mensagens.
Infelizmente, para usar esse algoritmo, você precisa manter o programa em execução constante de qualquer maneira. Assim que você interromper a execução do programa, as novas letras não serão mais excluídas automaticamente. Mas, nesse caso, há outra solução.
Pare de receber mensagens no endereço do Gmail gerado
O Gmail fornece algoritmos para filtrar as mensagens recebidas. Esses algoritmos funcionam no lado do serviço e nunca permitirão o envio de e-mails indesejados, se você, é claro, configurá-los corretamente. No momento, infelizmente, não podemos fornecer a funcionalidade de configurar remotamente esses filtros usando C ++, mas planejamos adicionar essa oportunidade em um futuro próximo. Por favor, siga nossas atualizações!
Portanto, se você quiser filtrar as mensagens que chegam ao Gmail gerado, primeiro você precisa criar um modelo de pesquisa para o filtro. Aqui está o código mais simples para obter o modelo:
//Generate Gmail search pattern
auto searchPattern = System::String(u"to:(") + generatedAddress->get_Address() + u")";
Console::WriteLine(searchPattern);
Aqui, a variável generatedAddress contém o Gmail gerado que foi criado anteriormente neste artigo. O código acima criará um modelo de pesquisa e o imprimirá no terminal. Copie esse modelo porque você precisará dele ao criar o filtro.
Agora vamos descrever passo a passo como você pode criar um filtro. Para começar, abra a interface web de e-mail do Gmail, disponível em o link. Nessa interface, encontre a barra de pesquisa:
Nessa barra de pesquisa, você precisa inserir o modelo gerado anteriormente nesta instrução. Em seguida, você precisa clicar no botão “Mostrar opções de pesquisa”, indicado na captura de tela abaixo:
Na janela de opções de pesquisa que se abre, você não precisa inserir nenhum dado adicional, o modelo gerado já configurou a pesquisa. Basta clicar no botão “Criar filtro”.
Como resultado, a janela de configurações do filtro será aberta:
Aqui você pode escolher o que o filtro deve fazer com os e-mails recebidos no endereço do Gmail gerado. Você pode arquivá-los automaticamente, marcá-los como lidos, excluí-los e assim por diante. Como regra geral, a melhor opção é excluir e-mails. O volume da caixa de correio é limitado, não faz sentido gastá-la no armazenamento de lixo. Depois de selecionar as ações adequadas para você, clique novamente no botão “Criar filtro”.
Feito! O filtro está totalmente configurado, então não há mais lixo eletrônico incomodando você.
Gerenciar filtros temporários do Gmail
Às vezes, as mensagens que você recebe de um site específico não são solicitadas. Eles simplesmente se tornam lixo na sua caixa de correio e impedem que você encontre nela o que é realmente importante e interessante para você. Como resultado, você cria um filtro que bloqueia mensagens indesejadas deste site. Mas e se as mensagens do site não forem mais spam? Por exemplo, você deseja recuperar sua senha. Um site envia um e-mail com um link para um formulário de redefinição de senha, mas você não pode recebê-lo porque o filtro exclui imediatamente o e-mail.
Felizmente, existe uma maneira elegante de sair dessa situação. Você pode reconfigurar temporariamente o filtro para que ele não exclua esses e-mails. Ou você pode remover completamente o filtro. Vamos ver como isso pode ser feito.
Primeiro, abra a interface web do Gmail. Na página que se abre, clique no botão “Configurações”:
Na janela que se abre, clique no botão “Ver todas as configurações”:
A janela de configurações da conta do Gmail será aberta. Ele contém várias guias para ajustar sua experiência de e-mail. Estamos interessados na guia “Filtros e endereços bloqueados”. Abra esta guia:
Na guia que se abre, você verá uma lista de filtros para os Gmails gerados que você criou anteriormente, bem como possivelmente outros filtros:
Pela descrição dos filtros, você pode determinar facilmente qual deles é responsável pelo endereço que você deseja desbloquear. Ao clicar no botão “excluir”, você pode desativar permanentemente o filtro. Se você clicar no botão “editar”, poderá reconfigurar o filtro. Por exemplo, em vez de excluir e-mails, você pode sinalizá-los. Dessa forma, você pode salvar o filtro e facilitar a ativação no futuro. Ao editar o filtro, você poderá receber os e-mails necessários do site. Assim que quiser bloquear novamente o Gmail gerado, abra o filtro novamente com o botão “editar” e reconfigure as ações.
Isso é tudo. Agora você é um profissional com endereços do Gmail gerados. Você pode criar um grande número de endereços e gerenciar com maestria o fluxo de e-mails que chegam ao seu Gmail. Usando endereços adicionais, você poderá rastrear sites que transferem seus dados para terceiros sem o seu consentimento. Você poderá bloquear spam sem precisar treinar novamente seu sistema anti-spam ou sem precisar pressionar os botões de cancelamento de inscrição várias vezes. Você pode automatizar a remoção de spam usando Aspose.Email.NET ou manualmente por meio das configurações e da interface do Gmail.