Create app.py

app.py

@@ -0,0 +1,320 @@
+import streamlit as st
+import base64
+import json
+import re
+import html
+from typing import Dict, List, Any
+import pandas as pd
+
+# Set page configuration
+st.set_page_config(
+    page_title="Proxy Server Decoder",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+class ProxyServerDecoder:
+    def __init__(self):
+        self.results = []
+    
+    def decode_proxy_entry(self, encoded_str: str) -> Dict[str, Any]:
+        """Decode a single proxy entry from base64 -> hex -> JSON"""
+        try:
+            # Add padding if needed
+            padding = len(encoded_str) % 4
+            if padding:
+                encoded_str += '=' * (4 - padding)
+            
+            # Step 1: Base64 decode
+            decoded_bytes = base64.b64decode(encoded_str)
+            
+            # Step 2: Convert hex to ASCII
+            hex_string = decoded_bytes.decode('ascii')
+            json_string = bytes.fromhex(hex_string).decode('ascii')
+            
+            # Step 3: Parse JSON
+            return {
+                "status": "success",
+                "decoded_data": json.loads(json_string),
+                "original_length": len(encoded_str)
+            }
+        except Exception as e:
+            return {
+                "status": "error", 
+                "error": f"Decoding failed: {str(e)}",
+                "original_length": len(encoded_str)
+            }
+    
+    def extract_entries_from_html(self, html_content: str) -> List[str]:
+        """Extract base64 entries from HTML data-ss attribute"""
+        try:
+            unescaped_html = html.unescape(html_content)
+            
+            # Multiple patterns to catch different HTML formats
+            patterns = [
+                r'data-ss="\[(.*?)\]"',
+                r"data-ss='\[(.*?)\]'",
+                r'data-ss=\s*\[\s*(.*?)\s*\]'
+            ]
+            
+            data_ss_content = None
+            for pattern in patterns:
+                match = re.search(pattern, unescaped_html, re.DOTALL)
+                if match:
+                    data_ss_content = match.group(1)
+                    break
+            
+            if not data_ss_content:
+                return []
+            
+            # Extract base64 strings
+            base64_pattern = r'["\']([A-Za-z0-9+/=]+)["\']'
+            entries = re.findall(base64_pattern, data_ss_content)
+            
+            return entries
+        except Exception as e:
+            st.error(f"Error extracting from HTML: {e}")
+            return []
+    
+    def process_html(self, html_content: str) -> Dict[str, Any]:
+        """Process HTML content and decode all entries"""
+        entries = self.extract_entries_from_html(html_content)
+        
+        if not entries:
+            return {
+                "status": "error",
+                "message": "No entries found in HTML"
+            }
+        
+        results = []
+        success_count = 0
+        
+        for i, entry in enumerate(entries):
+            result = self.decode_proxy_entry(entry)
+            result_data = {
+                "entry_number": i + 1,
+                "encoded_string": entry,
+                "encoded_preview": f"{entry[:20]}...{entry[-10:]}" if len(entry) > 40 else entry,
+                **result
+            }
+            results.append(result_data)
+            
+            if result["status"] == "success":
+                success_count += 1
+        
+        return {
+            "status": "success",
+            "statistics": {
+                "total_entries": len(entries),
+                "successful_decodes": success_count,
+                "failed_decodes": len(entries) - success_count,
+                "success_rate": f"{(success_count/len(entries))*100:.1f}%"
+            },
+            "results": results
+        }
+    
+    def process_single_entry(self, encoded_string: str) -> Dict[str, Any]:
+        """Process a single encoded string"""
+        return self.decode_proxy_entry(encoded_string)
+
+def main():
+    # Initialize decoder
+    decoder = ProxyServerDecoder()
+    
+    # Sidebar
+    st.sidebar.title("🔍 Proxy Server Decoder")
+    st.sidebar.markdown("""
+    Decode base64-encoded proxy server information from HTML script tags.
+    
+    ### How to use:
+    1. **Single Entry**: Paste a base64 string
+    2. **HTML Parser**: Paste HTML with data-ss attribute
+    3. View decoded results in tables and JSON
+    
+    ### Input Format:
+    ```html
+    <script data-ss="[&quot;BASE64_STRING&quot;,...]"></script>
+    ```
+    """)
+    
+    # Sample data
+    sample_html = '''<script
+    id="serverSelectorScript"
+    data-u="&quot;https://adnade.net/ptp/?user=platformsincome&amp;subid=131370&quot;"
+    data-d="0"
+    data-ss="[&quot;N2IyMjY5NjQyMjNhMzIzMDMxMmMyMjc1NzI2YzIyM2EyMjY4NzQ3NDcwNzMzYTVjMmY1YzJmMzEzMDM4MmUzMTM4MzEyZTMxMzEyZTMxMzczMTVjMmY1ZjVmNjM3MDMyMmU3MDY4NzAyMjJjMjI2ZTYxNmQ2NTIyM2EyMjcwNzM3OTYzNjg3YTRjNmY3MzQxNmU2NzY1NmM2NTczMzI0ZDIyN2Q=&quot;,&quot;N2IyMjY5NjQyMjNhMzEzODM1MmMyMjc1NzI2YzIyM2EyMjY4NzQ3NDcwNzMzYTVjMmY1YzJmMzkzNTJlMzIzMTM0MmUzNTMzMmUzNDM4NWMyZjVmNWY2MzcwMzIyZTcwNjg3MDIyMmMyMjZlNjE2ZDY1MjIzYTIyNmQ2NTc2NTM3MDYxNjM2NTU3NjE3MjczNjE3NzUwMjI3ZA==&quot;]"
+    ></script>'''
+    
+    # Main content
+    st.title("🔍 Proxy Server Decoder")
+    
+    # Tabs for different functionality
+    tab1, tab2, tab3 = st.tabs(["📄 HTML Parser", "🔤 Single Entry", "📊 Results"])
+    
+    with tab1:
+        st.header("HTML Content Parser")
+        
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            html_input = st.text_area(
+                "Paste your HTML content here:",
+                value=sample_html,
+                height=300,
+                placeholder="Paste HTML with data-ss attribute here..."
+            )
+        
+        with col2:
+            st.markdown("### Quick Actions")
+            if st.button("🚀 Use Sample Data", use_container_width=True):
+                st.session_state.sample_used = True
+            
+            if st.button("🗑️ Clear Input", use_container_width=True):
+                html_input = ""
+                st.rerun()
+            
+            st.markdown("---")
+            st.markdown("""
+            **Expected Format:**
+            ```html
+            <script data-ss="[&quot;base64_str1&quot;,&quot;base64_str2&quot;]">
+            ```
+            """)
+        
+        if st.button("🔍 Parse HTML", type="primary", use_container_width=True):
+            with st.spinner("Processing HTML content..."):
+                result = decoder.process_html(html_input)
+                st.session_state.html_result = result
+            
+            if result["status"] == "success":
+                st.success(f"✅ Successfully processed {result['statistics']['total_entries']} entries!")
+            else:
+                st.error(f"❌ {result.get('message', 'Processing failed')}")
+    
+    with tab2:
+        st.header("Single Entry Decoder")
+        
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
+            single_input = st.text_area(
+                "Enter base64 encoded string:",
+                height=150,
+                placeholder="Paste your base64 string here..."
+            )
+        
+        with col2:
+            st.markdown("### Example")
+            st.code("N2IyMjY5NjQyMjNhMz...", language="text")
+        
+        if st.button("🔍 Decode Single Entry", type="primary", use_container_width=True):
+            if single_input.strip():
+                with st.spinner("Decoding entry..."):
+                    result = decoder.process_single_entry(single_input.strip())
+                    st.session_state.single_result = result
+                
+                if result["status"] == "success":
+                    st.success("✅ Entry decoded successfully!")
+                else:
+                    st.error(f"❌ {result.get('error', 'Decoding failed')}")
+            else:
+                st.warning("⚠️ Please enter a base64 string")
+    
+    with tab3:
+        st.header("Decoding Results")
+        
+        # HTML Results
+        if 'html_result' in st.session_state:
+            result = st.session_state.html_result
+            
+            if result["status"] == "success":
+                # Statistics
+                stats = result["statistics"]
+                col1, col2, col3, col4 = st.columns(4)
+                
+                with col1:
+                    st.metric("Total Entries", stats["total_entries"])
+                with col2:
+                    st.metric("Successful", stats["successful_decodes"])
+                with col3:
+                    st.metric("Failed", stats["failed_decodes"])
+                with col4:
+                    st.metric("Success Rate", stats["success_rate"])
+                
+                # Results table
+                st.subheader("Decoded Entries")
+                
+                # Prepare data for table
+                table_data = []
+                for entry in result["results"]:
+                    row = {
+                        "Entry #": entry["entry_number"],
+                        "Status": "✅ Success" if entry["status"] == "success" else "❌ Failed",
+                        "Preview": entry["encoded_preview"],
+                        "Length": entry["original_length"]
+                    }
+                    
+                    if entry["status"] == "success":
+                        decoded = entry["decoded_data"]
+                        # Add decoded fields to row
+                        for key, value in decoded.items():
+                            row[key] = str(value)[:50] + "..." if len(str(value)) > 50 else str(value)
+                    
+                    table_data.append(row)
+                
+                # Display as dataframe
+                if table_data:
+                    df = pd.DataFrame(table_data)
+                    st.dataframe(df, use_container_width=True)
+                
+                # Detailed view
+                st.subheader("Detailed Results")
+                for entry in result["results"]:
+                    with st.expander(f"Entry #{entry['entry_number']} - {entry['encoded_preview']}"):
+                        if entry["status"] == "success":
+                            st.json(entry["decoded_data"])
+                        else:
+                            st.error(entry["error"])
+                
+                # Download results
+                st.subheader("Export Results")
+                json_str = json.dumps(result, indent=2)
+                st.download_button(
+                    label="📥 Download JSON Results",
+                    data=json_str,
+                    file_name="decoded_results.json",
+                    mime="application/json",
+                    use_container_width=True
+                )
+        
+        # Single Entry Results
+        elif 'single_result' in st.session_state:
+            result = st.session_state.single_result
+            
+            if result["status"] == "success":
+                st.success("✅ Decoding Successful!")
+                st.json(result["decoded_data"])
+                
+                # Download single result
+                json_str = json.dumps(result["decoded_data"], indent=2)
+                st.download_button(
+                    label="📥 Download Decoded Data",
+                    data=json_str,
+                    file_name="single_decoded.json",
+                    mime="application/json"
+                )
+            else:
+                st.error(f"❌ Decoding Failed: {result['error']}")
+        
+        else:
+            st.info("👆 Process some data in the other tabs to see results here!")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        "**Proxy Server Decoder** • Decodes base64 → hex → JSON proxy information"
+    )
+
+if __name__ == "__main__":
+    main()