Smartbox

Smartbox je Java aplikacija koja omogućuje logovanje na portal ePorezi uz pomoć sertifikata izdatog od strane Ministarstva unutrašnjih poslova, Pošte, Privredne komore Srbije, ili privatnih sertifikacionih tela (Halcom i E-Smart).

Baš Čelik podržava simulaciju Smartboxa, funkcionišući na potpuno isti način kao i Smartbox: uz pomoć pkcs11 modula koje pruža sertifikaciono tela. PKCS11 modul je dinamička biblioteka (.dll ili .so datoteke) koja bilo kom programu omogućava jednostavnu komunikaciju sa kriptografskim tokenom.

Svaki izdavač tokena izdaje i pkcs11 modul za taj token. Bez PKCS11 modula koji je kompajliran za određeni sistem, token se ne može koristiti na tom sistemu. Dole je navedeno za koje operativne sisteme su dostupni koji moduli:

	windows	linux	macos
MUP	✅
PKS	✅
Pošta	✅	✅	✅
Halcom	✅		✅
E-smart	✅	✅	✅

Za razliku od zvanične Smartbox aplikacije, Baš Čelik dozvoljava da se putanje do pkcs11 modula konfigurišu. Pri prvoj aktivaciji Smartbox moda u Baš Čeliku, ove putanje će biti postavljene na podrazumevane vrednosti, ali se mogu naknadno izmeniti.

Projekat srb-id-pkcs11 se bavi razvojem PKCS11 modula otvorenog koda za MUP-ove sertifikate (sertifikate sa lične karte).

Caution

Baš Čelik je za sada testiran samo sa MUP-ovim sertifikatom. Kako je i navedeno u licenci programa, autor Baš Čelik programa ne pruža bilo kakvu garanciju o funkcionisanju programa. Pažljivo testirajte logovanje na portal ePoreza (najbolje je da se prvo ulogujete sa nekim od zvaničnih metoda).

Sniffer

Rad zvanične Smartbox aplikacije može se nadgledati uz pomoć narednog programa. Potrebno je prvo pokrenuti naredni program, a tek onda pokrenuti Smartbox. Detalji o komunikaciji biće ispisani u konzoli. Program je veoma koristan za ispravljanje eventualnih bagova u Baš Čeliku.

package main

import (
	"context"
	"fmt"
	"net/http"
	"net/url"

	"github.com/coder/websocket"
)

var listenAddr = "localhost:17165"
var targetServer = "ws://localhost:20806"

func handleClientConnection(clientConn *websocket.Conn) {
	defer clientConn.CloseNow()

	u, err := url.Parse(targetServer)
	if err != nil {
		fmt.Println("Invalid WebSocket server URL:", err)
		return
	}

	headers := http.Header{}
	headers.Set("Origin", "eporezi.purs.gov.rs")

	ctx := context.Background()
	serverConn, _, err := websocket.Dial(ctx, u.String(), &websocket.DialOptions{HTTPHeader: headers})
	if err != nil {
		fmt.Println("Failed to connect to WebSocket server:", err)
		return
	}
	//defer serverConn.CloseNow()

	clientToServer := make(chan []byte)
	serverToClient := make(chan []byte)

	go func() {
		defer close(clientToServer)
		for {
			_, msg, err := clientConn.Read(ctx)
			if err != nil {
				fmt.Println("Client read error:", err)
				return
			}
			fmt.Println("[Client -> Server]", msg)
			clientToServer <- msg
		}
	}()

	go func() {
		defer close(serverToClient)
		for {
			_, msg, err := serverConn.Read(ctx)
			if err != nil {
				fmt.Println("Server read error:", err)
				return
			}
			fmt.Println("[Server -> Proxy]", msg)
			serverToClient <- msg
		}
	}()

	for {
		select {
		case msg, ok := <-clientToServer:
			if !ok {
				return
			}
			err := serverConn.Write(ctx, websocket.MessageText, msg)
			if err != nil {
				fmt.Println("Error forwarding to server:", err)
				return
			}

		case msg, ok := <-serverToClient:
			if !ok {
				return
			}
			err := clientConn.Write(ctx, websocket.MessageText, msg)
			if err != nil {
				fmt.Println("Error forwarding to client:", err)
				return
			}
		}
	}
}

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		clientConn, err := websocket.Accept(w, r, &websocket.AcceptOptions{
			OriginPatterns: []string{"eporezi.purs.gov.rs"},
		})
		if err != nil {
			fmt.Println("Failed to upgrade connection:", err)
			return
		}
		fmt.Println("Client connected:", r.RemoteAddr)
		go handleClientConnection(clientConn)
	})

	fmt.Println("WebSocket proxy listening on ws://", listenAddr)
	http.ListenAndServe(listenAddr, nil)
}