Running with Ruby

Tag: smtp (page 1 of 2)

Wyciek bazy sdu.pl i mailing do poszkodowanych z pomocą Rubiego (nie Railsów)

Wczoraj ktoś znalazł w Google zrzut z bazy danych, zawierającej loginy, hasła i e-maile użytkowników pewnego portalu (około 2,5 tysiąca). Przerażające jest to, że hasła nie były nawet hashowane (nie mówiąc już o soleniu). Wprawdzie baza była dość stara (2006 rok), jednak mając na uwadze dobro użytkowników, postanowiłem rozesłać im wiadomość e-mail informującą o konieczności zmiany haseł w swoich skrzynkach.

Oczywiście wykorzystałem do tego język Ruby. Mailing postanowiłem zrobić z serwera SMTP (maile rozsyłane z localhosta często automatycznie trafiają do spamu). Aby to w miarę sprawnie rozesłać, postanowiłem użyć biblioteki ActionMailer należącej do frameworka Ruby on Rails. Cały framework nie był mi potrzebny, więc załączyłem tylko to co trzeba.

Pierwszą rzeczą jaką należy zrobić, jest dołączenie bibliotek oraz konfiguracja ActionMailera:

#coding: utf-8
require 'action_mailer'

ActionMailer::Base.smtp_settings = {
    :domain => "nasza.domena.pl",
    :user_name=> "nasz@email.pl",
    :password=> "naszehaslo",
    :address=> "nasz.adres.pl",
    :port=> 587,
    :authentication=> :plain,
    :enable_starttls_auto=> true
}

Następnie tworzymy sobie klasę służącą do wysyłania emaili:

class Mailing < ActionMailer::Base
  def warning(to)
    recipients  to
    from    'nasz@adres.email'
    subject 'Wyciek bazy danych'
    body    'Treść wiadomości ostrzegawczej'
  end
end

Mamy już jak wysyłać wiadomość, musimy jeszcze mieć do kogo. Skorzystamy z wyrażenia regularnego, które z danego wiersza kodu, wyciągnie nam wszystkie adresy e-mail. Zadeklarujemy też sobie tablicę do której będziemy te adresy wrzucać:

reg = /[A-Z0-9._%-]+@([A-Z0-9-]+\.)+[A-Z]{2,4}/i
emails = []

Następnie otwieramy nasz plik z e-mailami (np. właśnie dump z bazy), i odczytując wiersz po wierszu, wyciągamy wszystkie adresy e-mail:

File.open("plik_zrodlowy.sql", "r") do |infile|
   while (line = infile.gets)
      next unless  line.scan(/#{reg}/).size > 0
      line.gsub(/#{reg}/).each { |em| emails << em }
   end
end

Wyciąganie odbywa się bardzo prosto. Najpierw sprawdzamy czy w danym wierszu istnieją jakiekolwiek dopasowania (adresy e-mail) i jeśli tak, to wrzucamy je do tablicy emails. Jeśli nie ma, przechodzimy do następnej linii.

Mamy już jak wysyłać, mamy też do kogo. Nie pozostaje nam nic innego jak to rozesłać. Zastosowałem poniżej najprostszą metodę możliwą. Jeden wątek i pętelka. Wydajniej byłoby zrobić to np w 2-3 wątkach, jednak było już późno i mi się nie chciało ;)

i = 0
emails.uniq.each do |email|
	i+=1
	begin
		Mailing.warning(email).deliver
	rescue Exception=>e
		puts e
	end
	puts "#{i} - #{email}"
end

W tym fragmencie interesujące są dwie rzeczy. Po pierwsze dzięki wywołaniu metody uniq na e-mailach, pozbywamy się powtórzeń, co gwarantuje nam że wiadomość zostanie wysłana tylko raz do danego odbiorcy.

Po drugie, korzystamy z bloku z przechwytywaniem wyjątków. Dzięki temu, nawet jeśli ActionMailer zwróci nam jakiś błąd przy którejś z wiadomości, rozsyłanie nie zostanie przerwane.

To by było na tyle. Przypominam tylko o tym, żeby nadmiernie nie spamować użytkowników ;)

Rails3, SMTP i różne konta (adresy) e-mail

Wysyłanie e-maili za pomocą Railsów jest bardzo proste. Zarówno przez sendmail jak i po smtp. Wystarczy w pliku config/production.rb (czy tez w innym – zależnie od środowiska), dodać następujące linijki:

  config.action_mailer.delivery_method = :smtp
  config.action_mailer.perform_deliveries = true
  config.action_mailer.raise_delivery_errors = true

  config.action_mailer.smtp_settings = {
    :address => "adres.serwera.smtp.pl",
    :port => 587,
    :domain => 'jakasmoja.domena.pl',
    :user_name => '<username>',
    :password => '<password>',
    :authentication => 'plain',
    :enable_starttls_auto => true
  }

i już nasza aplikacja Rails wysyła e-maile za pośrednictwem zewnętrznego serwera SMTP.

Problem pojawia się jeśli chcielibyśmy korzystać z różnych adresów e-mail, niekoniecznie na jednym serwerze SMTP. Takie przypisane na “sztywno” w configu ustawienia, pozwalają korzystać tylko z jednego serwera.

W starszych wersjach Railsów (1.x i 2.x) była sobie w mailerze zmienna @@smtp_settings która odpowiadała za przechowywanie ustawień związanych z serwerem SMTP. Nadpisanie tej zmiennej, powodowało automatyczne wysyłanie wiadomości z nowego (innego) serwera. W nowych Railsach ten mechanizm przestał działać. Zamiast zmiennej klasowej, jest teraz metoda self.smtp_settings w której przechowywane są ustawienia.

Aby sprawnie zarządzać kontami z których wysyłam maile, napisałem pewien niewielki kawałek kodu prezentowany poniżej. Ustawienia kont przechowywane są w plikach yaml, dzięki czemu łatwo można je edytować i zmieniać. Zanim zacznę, nadmienię tylko że konwencja nazewnicza w app/mailers nie do końca jest poprawna. Wynika ona z pewnych konwencji przyjętych przeze mnie jeszcze za czasów Rails2, gdzie Mailery znajdowały się w app/models. Nie ma to jednak żadnego wpływu na działanie kodu – piszę to tylko dlatego, że niektórzy mogliby się dziwić dlaczego mam namespace Mailer w app/mailers, skoro samo umiejscowienie w app/mailers, wskazuje na jego zawartość.

Proszę się nie czepiać że jest Mailer::Base i Mailer::Admin ;)

Wracając do sedna sprawy, chcielibyśmy wysyłać maile za pomocą różnych kont. Pierwszą rzeczą jaką musimy zrobić, jest powiadomienie Railsów o tym jak chcemy wysyłać maile w danym środowisku. Robimy to dodając w pliku config/environments/srodowisko.rb następujące linijki:

  config.action_mailer.delivery_method = :smtp
  config.action_mailer.perform_deliveries = true
  config.action_mailer.raise_delivery_errors = true

Mówią one o tym że chcemy wysyłać e-maile z pomocą SMTP, chcemy aby były wysyłane oraz chcemy być informowani jeśli z jakiegoś powodu e-mail nie zostanie wysłany. Kolejną rzeczą jaką zrobimy, będzie utworzenie katalogu config/mailers, w którym będziemy trzymać ustawienia związane z kontami.

W tym katalogu utwórzmy sobie plik yaml o nazwie admin. Dlaczego admin? Na potrzeby tutoriala będą dwie klasy:

  1. Mailer::Base
  2. Mailer::Admin

Pierwsza to klasa bazowa, z niej nie będziemy wysyłać e-maili. Drugą będzie wyżej wspomniana klasa Mailer::Admin. Właśnie stąd admin. Gdybyśmy mieli np Mailer::Newsletter, utworzylibyśmy plik newsletter.yml.

Plik ten ma następującą strukturę:

development:
  default:
    domain: "domena.pl"
    user_name: "mail@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true

production:
  default:
    domain: "domena.pl"
    user_name: "mail@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true

test:
  default:
    domain: "localhost"
    user_name: "login"
    password: "haselko"
    address: "localhost"
    port: 587
    authentication: plain

Plik taki zawiera deklarację domyślnych danych dostępowych dla każdego ze środowisk. Póki co nie zawiera nic więcej.

Zajmijmy się teraz naszą klasą bazową Mailer::Base:

# coding: utf-8
class Mailer::Base < ActionMailer::Base
  default :content_type => "text/html"
  # Czy załadowalismy sami ustawienia czy też zaraz przed wysłaniem ma
  # Załadować domyślne ustawienia
  @settings_loaded = false

  def mail(headers={}, &block)
    # Załaduj najpierw
    load_settings unless @settings_loaded
    super
  end

  private

  # Ładuje ustawienia specyficzne dla danego maila (skąd ma go wysyłać)
  # Ustawienia ładuje z yamla w config/mailer/
  def load_settings(mail = 'default')
    @settings_loaded = true
    # Wezmy nazwe tego modelu (bo z koncowej nazwy bedziemy brali parametr
    # dot. nazwy pliku w configach mailerów
    # Np. Mailer::Admin ==> admin.yml
    file_name = self.class.name.downcase.split('::').last
    # Wczytaj ustawienia
    options = YAML.load_file("#{Rails.root}/config/mailers/#{file_name}.yml")[Rails.env][mail]
    # Jeśli sie nie udało załadować takich ustawień to załaduj domyślne
    unless options
      options = YAML.load_file("#{Rails.root}/config/mailers/#{file_name}.yml")[Rails.env]['default']
    end
    # I załaduj je jako wlaściwe do wysłania maili
    options.each{|key, val|
      self.smtp_settings[key.to_sym] = val
    }
  end
end

Jak widać powyżej, kodu nie ma dużo. Pierwszą ważną rzeczą jest zmienna instancyjna @settings_loaded, która mówi nam, czy ustawienia dotyczące SMTP zostały już załadowane. Dzięki temu możemy rozpoznać, czy mamy ładować ustawienia domyślne, czy też załadowane zostały ustawienia specyficzne dla danego mailera. Dalej mamy przedefiniowaną metodę mail. Dodaliśmy tam tak naprawdę tylko jedną linijkę:

load_settings unless @settings_loaded

która załaduje nam domyślne ustawienia mailingowe, tylko jeśli ustawienia specyficzne nie zostały załadowane wcześniej.

Dalej mamy deklarację prywatnej metody load_settings, która przyjmuje jako parametr nazwę klucza z yamla, pod którym znajdują się parametry konta SMTP.

Przykładowo mając konto o kluczu “supermail”, ładowalibyśmy jego ustawienia w taki sposób:

load_settings('supermail')

Metoda ta stara się odczytać ustawienia z podanego klucza i jeśli się to nie uda to ładuje ustawienia domyślne.

Ustawienia ładowane są tutaj:

    options.each{|key, val|
      self.smtp_settings[key.to_sym] = val
    }

Tyle jeśli chodzi o klasę bazową dla naszych mailerów. Utwórzmy sobie teraz klasę Mailer::Admin, która będzie wysyłała maila z informacją o zmianie adresu e-mail.

# coding: utf-8
class Mailer::Admin < Mailer::Base
  default :from => "info@przyklad.pl"

  def email_confirm(user)
    load_settings('email_confirm')
    @title = "Potwierdzenie zmiany adresu e-mail użytkownika #{user.login.capitalize}"
    @login = user.login.capitalize
    @msg = 'Twój adres e-mail został zmieniony'
    mail(:to => user.email, :subject => @title)
  end

end

Dziedziczymy po naszym mailerze bazowym, podając domyślną wartość pola from. Ładujemy następnie ustawienia konta, specyficzne dla e-maili email_confirm. Jeśli pominęlibyśmy ładowanie ustawień, wtedy e-maile byłyby wysyłane z domyślnego konta jakie mamy skonfigurowane w pliku admin.yml.

I to by było na tyle. Nie zapomnijcie dodawać ustawień do plików yml, jeśli nie wysyłacie z konta domyślnego. Poniżej przykład pliku admin.yml, wraz z ustawieniami domyślnymi oraz specyficznymi dla email_confirm:

development:
  default:
    domain: "domena.pl"
    user_name: "mail@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true
  email_confirm:
    domain: "domena.pl"
    user_name: "confirmation@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true

production:
  default:
    domain: "domena.pl"
    user_name: "mail@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true
  email_confirm:
    domain: "domena.pl"
    user_name: "confirmation@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true

test:
  default:
    domain: "localhost"
    user_name: "login"
    password: "haselko"
    address: "localhost"
    port: 587
    authentication: plain
  email_confirm:
    domain: "domena.pl"
    user_name: "confirmation@domena.pl"
    password: "haselko"
    address: "adres.pl"
    port: 587
    authentication: plain
    enable_starttls_auto: true
Olderposts

Copyright © 2018 Running with Ruby

Theme by Anders NorenUp ↑